{ "cells": [ { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Fundamental Modules for Statistical Modelling\n", "\n", "Feng Li\n", "\n", "School of Statistics and Mathematics\n", "\n", "Central University of Finance and Economics\n", "\n", "[feng.li@cufe.edu.cn](mailto:feng.li@cufe.edu.cn)\n", "\n", "[https://feng.li/python](https://feng.li/python)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Install different version of Python modules \n", "\n", "\n", "- What if you want to install an application and leave it be? If an application works, any change in its libraries or the versions of those libraries can break the application. Also, what if you can’t install packages into the global site-packages directory, due to not having permissions to change the host python environment?\n", "\n", "- Sometimes it is useful to have different versions of Python modules installed at different places. A quick solution is to install Python packages at current working directory." ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Looking in indexes: https://mirrors.163.com/pypi/simple/\n", "Collecting pandas==1.2.1\n", " Using cached https://mirrors.163.com/pypi/packages/c9/56/f415b4148622f469263ad2ece8bdf757972e94ffc97cb750dd8b79b04d43/pandas-1.2.1-cp39-cp39-manylinux1_x86_64.whl (9.7 MB)\n", "Collecting pytz>=2017.3\n", " Using cached https://mirrors.163.com/pypi/packages/70/94/784178ca5dd892a98f113cdd923372024dc04b8d40abe77ca76b5fb90ca6/pytz-2021.1-py2.py3-none-any.whl (510 kB)\n", "Collecting numpy>=1.16.5\n", " Using cached https://mirrors.163.com/pypi/packages/7a/4c/dd00ce768b0f0f7de5c486cbd9f5b922bc3af2f3a5da30121d7f7dc03130/numpy-1.21.2-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl (15.8 MB)\n", "Collecting python-dateutil>=2.7.3\n", " Using cached https://mirrors.163.com/pypi/packages/d4/70/d60450c3dd48ef87586924207ae8907090de0b306af2bce5d134d78615cb/python_dateutil-2.8.1-py2.py3-none-any.whl (227 kB)\n", "Collecting six>=1.5\n", " Using cached https://mirrors.163.com/pypi/packages/ee/ff/48bde5c0f013094d729fe4b0316ba2a24774b3ff1c52d924a8a4cb04078a/six-1.15.0-py2.py3-none-any.whl (10 kB)\n", "Installing collected packages: six, pytz, python-dateutil, numpy, pandas\n", "Successfully installed numpy-1.21.2 pandas-1.2.1 python-dateutil-2.8.1 pytz-2021.1 six-1.15.0\n" ] } ], "source": [ "! pip3 install pandas==1.2.1 -I -t ." ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "'1.2.1'" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas\n", "pandas.__version__" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "fragment" } }, "source": [ "- In all these cases, [`virtualenv`](https://virtualenv.pypa.io/en/latest/) can also help you. It creates an environment that has its own installation directories, that doesn’t share libraries with other virtualenv environments (and optionally doesn’t access the globally installed libraries either)." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Python modules for Statistics\n", "\n", "## NumPy\n", "\n", "`NumPy` is short for Numerical Python, is the foundational package for scientific computing in Python. It contains among other things:\n", "\n", "- a powerful N-dimensional array object\n", "- sophisticated (broadcasting) functions\n", "- tools for integrating C/C++ and Fortran code\n", "- useful linear algebra, Fourier transform, and random number capabilities\n", "\n", "Besides its obvious scientific uses, NumPy can also be used as an efficient multi-dimensional container of generic data. Arbitrary data-types can be defined. This allows NumPy to seamlessly and speedily integrate with a wide variety of databases. \n", "\n", "- [NumPy Reference](https://numpy.org/doc/stable/reference/)\n", "- [NumPy User Guide](https://numpy.org/doc/stable/user/index.html)\n" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## SciPy \n", "\n", "`SciPy` is a collection of packages addressing a number of different standard problem domains in scientific computing. Here is a sampling of the packages included:\n", "\n", "- `scipy.integrate` : numerical integration routines and differential equation solvers.\n", "- `scipy.linalg` : linear algebra routines and matrix decompositions extending beyond those provided in `numpy.linalg`.\n", "- `scipy.optimize` : function optimizers (minimizers) and root finding algorithms." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "- `scipy.signal` : signal processing tools.\n", "- `scipy.sparse` : sparse matrices and sparse linear system solvers.\n", "- `scipy.special` : wrapper around SPECFUN, a Fortran library implementing many common mathematical functions, such as the gamma function.\n", "- `scipy.stats` : standard continuous and discrete probability distributions (density functions, samplers, continuous distribution functions), various statistical tests, and more descriptive statistics.\n", "- ... \n", "\n", "[SciPy Reference Guide](https://docs.scipy.org/doc/scipy/)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Linear Algebra\n", "\n", "Linear algebra can be done conveniently via `scipy.linalg`. When SciPy is built using the optimized ATLAS LAPACK and BLAS libraries, it has very fast linear algebra capabilities. If you dig deep enough, all of the raw lapack and blas libraries are available for your use for even more speed. In this section, some easier-to-use interfaces to these routines are described.\n", "\n", "All of these linear algebra routines expect an object that can be converted into a 2-dimensional array. The output of these routines is also a two-dimensional array." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Matrices and n-dimensional array" ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2],\n", " [3, 4]])" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "from scipy import linalg\n", "A = np.array([[1,2],[3,4]])\n", "A" ] }, { "cell_type": "code", "execution_count": 23, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[-2. , 1. ],\n", " [ 1.5, -0.5]])" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linalg.inv(A) # inverse of a matrix" ] }, { "cell_type": "code", "execution_count": 24, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[5, 6]])" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b = np.array([[5,6]]) #2D array\n", "b" ] }, { "cell_type": "code", "execution_count": 25, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[5],\n", " [6]])" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.T" ] }, { "cell_type": "code", "execution_count": 26, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[ 5, 12],\n", " [15, 24]])" ] }, "execution_count": 26, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A*b #not matrix multiplication!" ] }, { "cell_type": "code", "execution_count": 27, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[17],\n", " [39]])" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A.dot(b.T) #matrix multiplication" ] }, { "cell_type": "code", "execution_count": 28, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([5, 6])" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b = np.array([5,6]) #1D array\n", "b" ] }, { "cell_type": "code", "execution_count": 29, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "array([5, 6])" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b.T #not matrix transpose!" ] }, { "cell_type": "code", "execution_count": 30, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([17, 39])" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A.dot(b) #does not matter for multiplication" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "- Numpy array can easily convet to Pandas, and vise versa." ] }, { "cell_type": "code", "execution_count": 58, "metadata": { "slideshow": { "slide_type": "slide" } }, "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", "
012
0123
1456
\n", "
" ], "text/plain": [ " 0 1 2\n", "0 1 2 3\n", "1 4 5 6" ] }, "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import pandas as pd\n", "Ap = pd.DataFrame(A)\n", "Ap" ] }, { "cell_type": "code", "execution_count": 60, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2, 3],\n", " [4, 5, 6]])" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A2 = Ap.values\n", "A2" ] }, { "cell_type": "code", "execution_count": 61, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "numpy.ndarray" ] }, "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(A2)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Solving linear system¶" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[1, 2],\n", " [3, 4]])" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "from scipy import linalg\n", "A = np.array([[1,2],[3,4]])\n", "A" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[5],\n", " [6]])" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "b = np.array([[5],[6]])\n", "b" ] }, { "cell_type": "code", "execution_count": 31, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "array([-4. , 4.5])" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "linalg.inv(A).dot(b) #slow" ] }, { "cell_type": "code", "execution_count": 33, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[0.],\n", " [0.]])" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A.dot(linalg.inv(A).dot(b))-b #check" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[-4. ],\n", " [ 4.5]])" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.linalg.solve(A,b) #fast" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[0.],\n", " [0.]])" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "A.dot(np.linalg.solve(A,b))-b #check" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Determinant" ] }, { "cell_type": "code", "execution_count": 36, "metadata": { "slideshow": { "slide_type": "fragment" } }, "outputs": [ { "data": { "text/plain": [ "-2.0" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import numpy as np\n", "from scipy import linalg\n", "A = np.array([[1,2],[3,4]])\n", "linalg.det(A)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Least-squares problems and pseudo-inverses" ] }, { "cell_type": "code", "execution_count": 37, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "import numpy as np\n", "from scipy import linalg\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 38, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "c1, c2 = 5.0, 2.0\n", "i = np.r_[1:11]\n", "xi = 0.1*i\n", "yi = c1*np.exp(-xi) + c2*xi\n", "zi = yi + 0.05 * np.max(yi) * np.random.randn(len(yi))" ] }, { "cell_type": "code", "execution_count": 39, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "A = np.c_[np.exp(-xi)[:, np.newaxis], xi[:, np.newaxis]]\n", "c, resid, rank, sigma = linalg.lstsq(A, zi)" ] }, { "cell_type": "code", "execution_count": 40, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "xi2 = np.r_[0.1:1.0:100j]\n", "yi2 = c[0]*np.exp(-xi2) + c[1]*xi2" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(xi,zi,'x',xi2,yi2)\n", "plt.axis([0,1.1,3.0,5.5])\n", "plt.xlabel('$x_i$') # LaTeX symbols are also supported\n", "plt.title('Data fitting with linalg.lstsq')\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Eigenvalues and eigenvectors" ] }, { "cell_type": "code", "execution_count": 43, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(-0.3722813232690143+0j) (5.372281323269014+0j)\n", "[-0.82456484 0.56576746]\n", "[-0.41597356 -0.90937671]\n", "[1. 1.]\n", "5.551115123125783e-17\n" ] } ], "source": [ "import numpy as np\n", "from scipy import linalg\n", "A = np.array([[1,2],[3,4]])\n", "la,v = linalg.eig(A)\n", "l1,l2 = la\n", "print(l1, l2) #eigenvalues\n", "\n", "print(v[:,0]) #first eigenvector\n", "\n", "print(v[:,1]) #second eigenvector\n", "\n", "print(np.sum(abs(v**2),axis=0)) #eigenvectors are unitary\n", "\n", "v1 = np.array(v[:,0]).T\n", "print(linalg.norm(A.dot(v1)-l1*v1)) #check the computation" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Singular Value Decomposition (SVD)" ] }, { "cell_type": "code", "execution_count": 44, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "import numpy as np\n", "from scipy import linalg\n", "A = np.array([[1,2,3],[4,5,6]])" ] }, { "cell_type": "code", "execution_count": 45, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "M,N = A.shape\n", "U,s,Vh = linalg.svd(A)\n", "Sig = linalg.diagsvd(s,M,N)" ] }, { "cell_type": "code", "execution_count": 46, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[-0.3863177 , 0.92236578],\n", " [-0.92236578, -0.3863177 ]])" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "U, Vh = U, Vh\n", "U" ] }, { "cell_type": "code", "execution_count": 47, "metadata": { "scrolled": true, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[9.508032 , 0. , 0. ],\n", " [0. , 0.77286964, 0. ]])" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Sig" ] }, { "cell_type": "code", "execution_count": 48, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[-0.42866713, -0.56630692, -0.7039467 ],\n", " [-0.80596391, -0.11238241, 0.58119908],\n", " [ 0.40824829, -0.81649658, 0.40824829]])" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Vh" ] }, { "cell_type": "code", "execution_count": 49, "metadata": { "scrolled": true, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "data": { "text/plain": [ "array([[1., 2., 3.],\n", " [4., 5., 6.]])" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" } ], "source": [ "U.dot(Sig.dot(Vh)) #check computation" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## QR decomposition\n", "\n", "The command for QR decomposition is `linalg.qr`." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## LU decomposition\n", " \n", "The SciPy command for this decomposition is `linalg.lu`. If the intent for performing LU decomposition is for solving linear systems then the command `linalg.lu_factor` should be used followed by repeated applications of the command `linalg.lu_solve` to solve the system for each new right-hand-side." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Cholesky decomposition\n", "\n", "The command `linalg.cholesky` computes the cholesky factorization. For using Cholesky factorization to solve systems of equations there are also `linalg.cho_factor` and `linalg.cho_solve` routines that work similarly to their LU decomposition counterparts." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Statistical Distributions\n", "\n", "A large number of probability distributions as well as a growing library of statistical functions are available in `scipy.stats`. See http://docs.scipy.org/doc/scipy/reference/stats.html for a complete list." ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "- Generate random numbers from normal distribution:" ] }, { "cell_type": "code", "execution_count": 34, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "from scipy.stats import norm\n", "r = norm.rvs(loc=0, scale=1, size=1000)" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "- Calculate a few first moments:" ] }, { "cell_type": "code", "execution_count": 35, "metadata": { "collapsed": true, "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "mean, var, skew, kurt = norm.stats(moments='mvsk')" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "# Linear regression model\n", "\n", "This example computes a least-squares regression for two sets of measurements." ] }, { "cell_type": "code", "execution_count": 50, "metadata": { "scrolled": true, "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'slope': 0.0016389519609387667, 'intercept': 0.5367248508312181}\n", "{'p_value': 0.9950296225204127, 'r-squared': 0.0}\n" ] } ], "source": [ "from scipy import stats\n", "import numpy as np\n", "x = np.random.random(10)\n", "y = np.random.random(10)\n", "slope, intercept, r_value, p_value, std_err = stats.linregress(x,y)\n", "print({'slope':slope,'intercept':intercept})\n", "print({'p_value':p_value,'r-squared':round(r_value**2,2)})" ] }, { "cell_type": "markdown", "metadata": { "slideshow": { "slide_type": "slide" } }, "source": [ "## Optimization\n", "\n", "The `minimize` function provides a common interface to unconstrained and constrained minimization algorithms for multivariate scalar functions in `scipy.optimize`" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [], "source": [ "import numpy as np\n", "from scipy.optimize import minimize\n", "\n", "def rosen(x):\n", " \"\"\"The Rosenbrock function\"\"\"\n", " return sum(100.0*(x[1:]-x[:-1]**2.0)**2.0 + (1-x[:-1])**2.0)" ] }, { "cell_type": "code", "execution_count": 64, "metadata": { "slideshow": { "slide_type": "slide" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Optimization terminated successfully.\n", " Current function value: 0.000000\n", " Iterations: 339\n", " Function evaluations: 571\n", "[1. 1. 1. 1. 1.]\n" ] } ], "source": [ "x0 = np.array([1.3, 0.7, 0.8, 1.9, 1.2])\n", "\n", "## Calling the minimize() function\n", "res = minimize(rosen, x0, method='nelder-mead',\n", " options={'xtol': 1e-8, 'disp': True})\n", "print(res.x)" ] } ], "metadata": { "celltoolbar": "Slideshow", "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.10.9" }, "rise": { "auto_select": "first", "autolaunch": false, "enable_chalkboard": true, "start_slideshow_at": "selected", "theme": "black" } }, "nbformat": 4, "nbformat_minor": 1 }