Library updates

1.2.5 - May 5, 2023 - New distribution statinf.distributions.discrete.NegativeBinomial() available

Statinf’s distributions module now includes a class for the Negative Binomial distribution. In the same spirit as already available distributions, the module allows to estimate parameters from data via Maximum Likelihood Estimation (MLE) and generate samples from the estimated (or user-provided) parameters.

In this release, the computations for the normalizing factor in the Conway-Maxwell Poisson distribution (statinf.distributions.discrete.CMPoisson.Z()) has been improved. This now offers stable results of the computation heavy factor improving the results from the parameters estimation. The new implementation also simplifies computations of the infinite sum of factorials by using mathematical tricks. Exploiting the fact that \(a^{b} = \exp(b \cdot \log(a))\), we can simplify factors such as \((j!)^{\nu}\) to be \(\exp \left(\nu \cdot \sum_{i=1}^{j} {\log(i)} \right)\). This significantly speeds up computations while leading to the same results.

The main changes are:

• statinf.distributions.discrete.NegativeBinomial() for the generic Poisson distribution

• statinf.distributions.discrete.CMPoisson.Z() improved implementation of the normalizing factor

from statinf.distributions import NegativeBinomial

# Let us generate a random sample of size 1000
x = NegativeBinomial(n_=5, p_=0.15).sample(size=1000)

# We can also estimate the parameters from the generated sample
# We just need to initialize the class...
nb = NegativeBinomial()

# ... and we can fit from the generated sample. The function returns a dictionary
nb.fit(x)
# The class stores the value of the estimated parameters,
# wo we can generate more samples using the fitted parameters
y = nb.sample(200)

pip3 install statinf==1.2.4

1.2.0 - February 5, 2023 - New module statinf.distributions() available for discrete distributions

Statinf now includes a module for proability distributions. The module allows to estimate parameters from data via Maximum Likelihood Estimation (MLE) and generate samples from the estimated (or user-provided) parameters. The module currently include discrete distributions, continuous distributions will be added later.

The main additions are:

• statinf.distributions.discrete.Poisson() for the generic Poisson distribution

• statinf.distributions.discrete.CMPoisson() for the Conway-Maxwell Poisson distribution, a generalization of the Poisson

More discrete and continuous distributions will be added soon.

from statinf.distributions import Poisson

# Let us generate a random sample of size 1000
x = Poisson(lambda_=2.5).sample(size=1000)

# We can also estimate the parameter from the generated sample
# We just need to initialize the class...
poiss = Poisson()

# ... and we can fit from the generated sample. The function returns a dictionary
poiss.fit(x)

# The class stores the value of the estimated parameters,
# so we can generate more samples using the fitted parameters
y = poiss.sample(200)

pip3 install statinf==1.2.0

1.1.0 - March 7, 2021 - New backend dependency for statinf.ml.neuralnetwork() module

Jax is now the new dependency for Statinf Deep Learning module. The module supports the same functionalities but the backend has moved from theano to jax. The library offers auto-gradient computations that better scale with GPUs for high performance.

The main changes are:

• statinf.ml.optimizers.SGD() offer the argument alpha as the momentum parameter and replaces the function statinf.ml.optimizers.MomentumSGD().

• statinf.ml.neuralnetwork.MLP.fit() replaces the previous train() function and offers the same functionalities.

• The value for the parameters of the optimizer can now be passed through the statinf.ml.neuralnetwork.MLP.fit() function.

More functionalities will soon be available.

from statinf.ml import MLP, Layer

# Initialize the network and its architecture
nn = MLP(loss='mse')
nn.add(Layer(4, 1, activation='linear'))

# Train the neural network
nn.fit(data=data, X=X, Y=Y, epochs=1, learning_rate=0.001)

pip3 install statinf==1.1.0

1.0.28 - September 27, 2020 - Time series module statinf.stats.timeseries() available

New functions for time series are now available in the statinf.stats module.

The current functions available are:

• statinf.stats.timeseries.adf_test() for Augmented Dickey-Fuller test.

• statinf.stats.timeseries.coint_test() for cointegration test.

More functionalities will soon be available.

from statinf.stats import adf_test, coint_test

import requests
import pandas as pd

# Function to generate data
def get_bitfinex_asset(asset, ts_start=None, ts_end=None):
    # Defaults from 1 January 2018, 00:00:00
    ts_ms_start = 1514768400000 if ts_start is None else ts_start
    ts_ms_end = int(datetime.datetime.now().timestamp()*100) if ts_end is None else ts_end
    url = 'https://api.bitfinex.com/v2/candles/trade:1D:t' + asset + '/hist'
    params = { 'start': ts_ms_start, 'end': ts_ms_end, 'sort': 1}
    r = requests.get(url, params=params)
    data = r.json()
    return pd.DataFrame(data)[2]

# Create the data series
series = get_bitfinex_asset(asset='BTCUSD')
series2 = get_bitfinex_asset(asset='NEOUSD')

# Test stationarity of the first series with ADF test
ts.adf_test(series, trend='ct')
# Test cointegration of both series
ts.coint_test(series, series2, trend='ct')

pip3 install statinf==1.0.28

1.0.27 - September 13, 2020 - New module statinf.data.ProcessData.Scaler()

A new functionality is now available for Machine Learning models to scale data. The class statinf.data.ProcessData.Scaler() includes the below methods:

• MinMax Scales the data to range between 0 and 1.

• Normalize Scales the data to have mean 0 and standard deviation 1 (user can chose to center or reduce or not).

from statinf.data import Scaler

# Load the Scaler class
scaler = Scaler(data=df, columns=['X1', 'X2'])
# Scale our dataset with MinMax method
scaled_df = scaler.MinMax()
print(scaled_df)
# Unscale data
unscaled_df = scaler.unscaleMinMax(scaled_df)
print(unscaled_df)

pip3 install statinf==1.0.27

1.0.23 - May 17, 2020 - New model GLM() and improved features for OLS()

• GLM

STATINF now provides a module for Generalized Linear Models: statinf.regressions.glm.GLM(). The module currently implements binomial and gaussian families of distribution for Logit and Probit models. We will soon extend to other families.

The module will also propose different heteroskedastic-robut covariance estimates such as Sandwich, \(HC0\), \(HC1\), \(HC2\) and \(HC3\) (non-robust is currently available). The module fits the model with the Newton-Raphson’s method. It proposes a function for Partial and Average Partial Effect (statinf.regressions.glm.GLM.partial_effects()).

• OLS

The argument in statinf.regressions.LinearModels.OLS() now supports variable transformations. You can run you regressions and created interaction variables in the forumla. This can be particularly useful for difference in differences.

Also, the function statinf.regressions.LinearModels.OLS.predict() has been upgraded and can not return confidence intervals for prediction. The function will continue to return a numpy.array for standard predictions and will return a pandas.DataFrame for confidence intervals.

• BinaryPerformance

The syntax issues encountered in statinf.ml.performance.BinaryPerformance() in version 1.1.16 have been fixed. The module is now fully working.

from statinf.regressions import GLM

# We set the Logit formula
formula = "Y ~ X0 + X1 + X2 + X3 + X4"
# We fit the GLM with the data, the formula and without intercept
logit = GLM(formula, data, fit_intercept=False, family='binomial')
logit.fit(cov_type='nonrobust', plot=False)

logit.summary()

pip3 install statinf==1.0.23

1.0.21 - Apr 26, 2020 - New module stats()

STATINF now comes with an advanced statistics modules.

It allows to get traditional descriptive statistics such as statinf.stats.descriptive.var(), statinf.stats.descriptive.cov() but also statinf.stats.descriptive.pearson() and statinf.stats.descriptive.spearman().

This modules also provides statistical tests statinf.stats.tests.ttest() for one sample and statinf.stats.tests.ttest_2samp() as well as statinf.stats.tests.kstest().

from statinf import stats

# Normality test
stats.kstest(data.X)

# 1-sample test for a mean
stats.ttest([30.02, 29.99, 30.11, 29.97, 30.01, 29.99], mu=30)

# 2-sample test for comparing means
stats.ttest(a, b)

pip3 install statinf==1.0.21

1.0.19 - Apr 17, 2020 - Update for OLS() summary

The summary statinf.regressions.LinearModels.OLS() model has been improved with better layout and the possibility to return a DataFrame. This will allow users to extract individual components (such as variable p-value, coefficients, …) for automation purposes.

from statinf.regressions import OLS

# We set the OLS formula
formula = "Y ~ X1 + X2 + X3 + X0"
# We fit the OLS with the data, the formula and without intercept
ols = OLS(formula, data, fit_intercept=False)

ols.summary()

pip3 install statinf==1.0.19

1.0.16 - Mar 22, 2020 - New module BinaryPerformance()

A new modules has been implemented for evaluation binary classification problem with statinf.ml.performance.BinaryPerformance(). The module (model agnostic) takes the prediction from a model and can return: model accuracy, confusion matrix, F1-score, precision and recall.

from statinf.ml.performance import BinaryPerformance

## Load the performance class
perf = BinaryPerformance(y_true=data[Y].values, y_pred=predicted)

## Model accuracy
print(perf.accuracy())
## Confusion matrix
print(perf.confusion())

pip3 install statinf==1.0.16

1.0.12 - Mar 10, 2020 - New optimizers available

Multiple optimizers have been added on top of the traditional SGD(). statinf.ml.neuralnetwork.MLP() now supports statinf.ml.optimizers.Adam(), statinf.ml.optimizers.AdaMax(), statinf.ml.optimizers.AdaGrad(), statinf.ml.optimizers.SGD(), statinf.ml.optimizers.MomentumSGD() and statinf.ml.optimizers.RMSprop().

from statinf.ml import MLP, Layer

# Initialize the network and its architecture
nn = MLP(loss='mse')
nn.add(Layer(4, 1, activation='linear'))

# Train the neural network
nn.train(data=data, X=X, Y=Y, epochs=1, learning_rate=0.001, optimizer='adam')

pip3 install statinf==1.0.12

1.0.7 - Feb 1, 2020 - New model MLP()

STATINF now offers a Neural Network framework with statinf.ml.neuralnetwork.MLP(). It is powered by theano and numpy. It allows to run a model on multiple CPUs or with GPUs (see Theano documentation).

from statinf.ml import MLP, Layer

# Initialize the network and its architecture
nn = MLP(loss='mse')
nn.add(Layer(4, 1, activation='linear'))

# Train the neural network
nn.train(data=data, X=X, Y=Y, epochs=1, learning_rate=0.001)

pip3 install statinf==1.0.7