Math-Modeling-gitea/数理统计.ipynb at master - Math-Modeling-gitea - WXXXXX

2437 lines

361 KiB

Plaintext

Raw Permalink Blame History

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

 {
  "cells": [
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "# 1 动手学数理统计"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 1.1 总体与样本"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 总体：将试验的全部可能的观察值称为**总体**，这些观察值可能是有限的，也可能是无限的，分别对应有限总体和无限总体，每一个可能观察值称为**个体**。\n",
     "> 由于总体的每一个个体都是随机试验的一个观察值，因此它是某一随机变量$X$的值，一个总体便对应一个随机变量$X$，对随机变量$X$的研究就是对总体的研究，随机变量$X$和总体具有相同的分布函数和数字特征。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 样本：设$X$是具有分布函数$F$的随机变量，若$X_{1}, X_{2}, \\cdots, X_{n}$是具有同一分布函数$F$的、相互独立的随机变量，则称$X_{1}, X_{2}, \\cdots, X_{n}$为从分布函数$F$（或总体$F$、或总体$X$）得到的容量为$n$的简单随机样本，简称**样本**，他们的观察值$x_{1}, x_{2}, \\cdots, x_{n}$称为**样本值**，又称为$X$的$n$个独立的观察值。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 由样本的定义（样本中$n$个随机变量相互独立）得：\n",
     "> - 1. 样本（$X_{1}, X_{2}, \\cdots, X_{n}$）的分布函数为$$F^{*}(x_{1}, x_{2}, \\cdots, x_{n})=\\prod_{i=1}^{n}F(x_{i})$$\n",
     "> - 2. 样本（$X_{1}, X_{2}, \\cdots, X_{n}$）的概率密度为$$f^{*}(x_{1}, x_{2}, \\cdots, x_{n})=\\prod_{i=1}^{n}f(x_{i})$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 1.2 经验分布函数、直方图与箱线图"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 经验分布函数：设  $x_{1}, x_{2}, \\cdots, x_{n}$  是取自总体分布函数为  $F(x)$  的样本，若将样本观测值由小到大进行排列，记为  $x_{(1)}, x_{(2)}, \\cdots, x_{(n)}$ , 则  $x_{(1)}, x_{(2)}, \\cdots, x_{(n)}$  称为有序样本，用有序样本 定义如下函数\n",
     "$$\n",
     "F_{n}(x)=\\left\\{\\begin{array}{ll}\n",
     "0, & \\text { 当 } x<x_{(1)}, \\\\\n",
     "k / n, & \\text { 当 } x_{(k)} \\leqslant x<x_{(k+1)}, k=1,2, \\cdots, n-1, \\\\\n",
     "1, & \\text { 当 } x \\geqslant x_{(n)},\n",
     "\\end{array}\\right.\n",
     "$$\n",
     "则  $F_{n}(x)$  是一非减右连续函数，且满足\n",
     "$$\n",
     "F_{n}(-\\infty)=0 \\text { 和 } F_{n}(\\infty)=1 .\n",
     "$$\n",
     "\n",
     "称  $F_{n}(x)$  为该样本的经验分布函数。\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 经验分布函数$F_{n}(x)$是总体分布函数$F(x)$的良好的近似。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🔥例子: 随机观察总体  $X$ , 得到一个容量为 10 的样本:\n",
     "$$\n",
     "3.2, \\quad 2.5, \\quad-2, \\quad 2.5, \\quad 0, \\quad 3, \\quad 2, \\quad 2.5,2, \\quad 4\n",
     "$$\n",
     "求  $\\mathrm{X}$  经验分布函数。\n",
     "\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🦊解:    \n",
     "1. 排序  $$-2, \\quad 0, \\quad 2, \\quad 2, \\quad 2.5, \\quad 2.5, \\quad 2.5, \\quad 3, \\quad 3.2, \\quad 4 $$\n",
     "2. 利用公式计算：\n",
     "$$\n",
     "F_{n}(x)=\\left\\{\\begin{array}{ll}\n",
     "0, & \\text { 当 } x<x_{(1)}, \\\\\n",
     "k / n, & \\text { 当 } x_{(k)} \\leqslant x<x_{(k+1)}, k=1,2, \\cdots, n-1, \\\\\n",
     "1, & \\text { 当 } x \\geqslant x_{(n)},\n",
     "\\end{array}\\right.\n",
     "$$\n",
     "3. 得:\n",
     "$$\n",
     "F_{10}(x)=\\left\\{\\begin{array}{cc}\n",
     "0, & x<-2 \\\\\n",
     "1 / 10, & -2 \\leq x<0 \\\\\n",
     "2 / 10, & 0 \\leq x<2 \\\\\n",
     "4 / 10, & 2 \\leq x<2.5 \\\\\n",
     "7 / 10, & 2.5 \\leq x<3 \\\\\n",
     "8 / 10, & 3 \\leq x<3.2 \\\\\n",
     "9 / 10, & 3.2 \\leq x<4 \\\\\n",
     "1, & x \\geq 4\n",
     "\\end{array}\\right.\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 直方图：为研究总体分布的性质，通过独立重复试验得到其样本的观察值$x_{1}, x_{2}, \\cdots, x_{n}$，将这些数据进行整理，并以表格或图形的方式展现出来，从而推测出总体的分布。直方图可以反映样本的概率密度，由于样本和其总体服从同一分布，且具有相同的数字特征，则样本的概率密度可看作是总体的概率密度。直方图包括**频数直方图**和**频率直方图**。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 直方图的绘制步骤：假设一样本包含$n$个样本值$（x_{1}, x{2}, \\cdots, x_{n}）$\n",
     "> - 1. 选取区间$[a, b]$， $a$要小于样本中最小的样本值，$b$要大于样本中最大的样本值;\n",
     "> - 2. 将选取的区间分为$k$个小区间，小区间的长度记为$\\bigtriangleup , \\bigtriangleup  = \\frac{b-a}{k}$;💡tips:当$n< 50$时，$k$取$5 \\sim 6$, 当$n$较大时，$k$取$10 \\sim 20$，若$k$取太大，则会出现小区间内频数为$0$的情况（应尽量避免）;\n",
     "> - 3. 统计小区间$([a+i\\bigtriangleup , a+(i+1)\\bigtriangleup ], i = 0, 1, \\cdots,k-1)$内样本中个体出现的次数$\\{f_{j}, j = 1, 2, \\cdots, k-1 \\}$，或频率$\\{ f_{j}/n, j = 1, 2, \\cdots, k-1 \\}$;\n",
     "> - 4. 将选取的区间$[a, b]$作为横轴，样本中个体出现的次数$\\{ f_{j}, j = 1, 2, \\cdots, k-1 \\}$或频率$\\{ f_{j}/n, j = 1, 2, \\cdots, k-1 \\}$作为纵轴；\n",
     "> - 5. 画出每个小区间及其对应的样本中个体次数（频数）的柱状图则得到直方图。\n",
     "\n",
     "> 将样本中个体出现的次数$\\{ f_{j}, j = 1, 2, \\cdots, k-1\\}$作为纵轴得到的直方图为频数直方图，将样本中个体出现的频率$\\{f_{j}/n, j = 1, 2, \\cdots, k-1\\}$作为纵轴得到的直方图为频率直方图。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🔥例子：画出下列样本的直方图\n",
     "$$\n",
     "\\begin{aligned}\n",
     " &138, \\quad 142, \\quad 148, \\quad 145, \\quad 140, \\quad 141 \\\\\n",
     " &138, \\quad 139, \\quad 144, \\quad 138, \\quad 139, \\quad 136 \\\\\n",
     " &138, \\quad 137, \\quad 137, \\quad 133, \\quad 140, \\quad 130\\\\\n",
     " &145, \\quad 141, \\quad 135, \\quad 131, \\quad 136, \\quad 131\\\\\n",
     " &134, \\quad 132, \\quad 135, \\quad 134, \\quad 132, \\quad 134\\\\\n",
     " &130, \\quad 135, \\quad 135, \\quad 134, \\quad 136, \\quad 131\\\\\n",
     " &139, \\quad 140, \\quad 141, \\quad 138, \\quad 137, \\quad 137\\\\\n",
     " &131, \\quad 127, \\quad 136, \\quad 128, \\quad 138, \\quad 132\\\\\n",
     " &134, \\quad 136, \\quad 137, \\quad 133, \\quad 121, \\quad 129\\\\\n",
     " &137, \\quad 132, \\quad 131, \\quad 139, \\quad 136, \\quad 135\\\\\n",
     " \\end{aligned}\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码（求解题）"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
      },
      "metadata": {
       "needs_background": "light"
      },
      "output_type": "display_data"
     },
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
      },
      "metadata": {
       "needs_background": "light"
      },
      "output_type": "display_data"
     }
    ],
    "source": [
     "# 1. 按照直方图的步骤一步一步画图\n",
     "import matplotlib.pyplot as plt\n",
     "# 图像嵌入\n",
     "%matplotlib inline  \n",
     "plt.rcParams['font.sans-serif']=['SimHei','Songti SC','STFangsong']\n",
     "plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号\n",
     "import numpy as np\n",
     "import warnings\n",
     "warnings.filterwarnings(\"ignore\")\n",
     "\n",
     "# 样本值\n",
     "x = [138, 142, 148, 145, 140, 141,\n",
     "    138, 139, 144, 138, 139, 136,\n",
     "    138, 137, 137, 133, 140, 130,\n",
     "    145, 141, 135, 131, 136, 131,\n",
     "    134, 132, 135, 134, 132, 134,\n",
     "    130, 135, 135, 134, 136, 131,\n",
     "    139, 140, 141, 138, 137, 137,\n",
     "    131, 127, 136, 128, 138, 132,\n",
     "    134, 136, 137, 133, 121, 129,\n",
     "    137, 132, 131, 139, 136, 135]\n",
     "\n",
     "# 1. 选取区间 [a, b]\n",
     "a = np.min(x) - 1\n",
     "b = np.max(x) + 1\n",
     "\n",
     "# 2. 分区间\n",
     "n = len(x)\n",
     "if n < 50:\n",
     "    k = 6\n",
     "elif n < 100:\n",
     "    k = 8\n",
     "else:\n",
     "    k =15\n",
     "\n",
     "delta = (b - a) / k\n",
     "\n",
     "# 3. 统计\n",
     "region_ab = np.zeros(k)   # 存储区间[a, b]的每个小区间\n",
     "fi = np.zeros(k)      # 存储每个小区间样本值的频数\n",
     "for i in range(k):\n",
     "    region_ab[i] = a+i*delta + (delta / 2)\n",
     "\n",
     "for idx, cen in enumerate(region_ab):\n",
     "    for data in x:\n",
     "        if data >= (cen - delta/2) and data <= (cen + delta/2):\n",
     "                fi[idx] += 1\n",
     "        else:\n",
     "            continue\n",
     "\n",
     "fi_n = fi / n     # 计算频率\n",
     "# 4. 画图\n",
     "\n",
     "# plt.figure(figsize=(10, 8))\n",
     "plt.bar(region_ab, fi, width=delta)   # 频数直方图\n",
     "plt.title('频数直方图')\n",
     "plt.xlabel('x')\n",
     "plt.ylabel('fi')\n",
     "plt.show()\n",
     "# plt.figure(figsize=(10, 8))\n",
     "plt.bar(region_ab, fi_n, width=delta)  # 频率直方图\n",
     "plt.title('频率直方图')\n",
     "plt.xlabel('x')\n",
     "plt.ylabel('fi/n')\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 2,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
      },
      "metadata": {
       "needs_background": "light"
      },
      "output_type": "display_data"
     },
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
      },
      "metadata": {
       "needs_background": "light"
      },
      "output_type": "display_data"
     }
    ],
    "source": [
     "# 2. 利用matplotlib.pyplot 中的hist方法直接画图\n",
     "import matplotlib.pyplot as plt\n",
     "# 图像嵌入\n",
     "%matplotlib inline  \n",
     "plt.rcParams['font.sans-serif']=['SimHei','Songti SC','STFangsong']\n",
     "plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号\n",
     "import numpy as np\n",
     "import warnings\n",
     "warnings.filterwarnings(\"ignore\")\n",
     "# 样本值\n",
     "x = [138, 142, 148, 145, 140, 141,\n",
     "    138, 139, 144, 138, 139, 136,\n",
     "    138, 137, 137, 133, 140, 130,\n",
     "    145, 141, 135, 131, 136, 131,\n",
     "    134, 132, 135, 134, 132, 134,\n",
     "    130, 135, 135, 134, 136, 131,\n",
     "    139, 140, 141, 138, 137, 137,\n",
     "    131, 127, 136, 128, 138, 132,\n",
     "    134, 136, 137, 133, 121, 129,\n",
     "    137, 132, 131, 139, 136, 135]\n",
     "    \n",
     "a = np.min(x) - 1\n",
     "b = np.max(x) + 1\n",
     "k = 8\n",
     "# plt.figure(figsize=(10, 8))\n",
     "plt.hist(x, bins=k, alpha=0.8, range=(a, b), density=None)  # density = None, 频数直方图\n",
     "plt.title('频数直方图')\n",
     "plt.xlabel('x')\n",
     "plt.ylabel('fi')\n",
     "plt.show()\n",
     "# plt.figure(figsize=(10, 8))\n",
     "plt.hist(x, bins=k, alpha=0.8, range=(a, b), density=True)  # density = True, 频率直方图\n",
     "plt.title('频率直方图')\n",
     "plt.xlabel('x')\n",
     "plt.ylabel('fi/n')\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 箱线图"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "&emsp;&emsp;首先介绍**样本分位数**：设有容量为$n$的样本观察值$x_{1}, x_{2}, \\cdots, x_{n}$，样本$p$分位数$(0<p<1)$记为$x_{p}$，它具有以下性质：(1)至少有$np$个观察值小于或等于$x_{p}$；(2)至少有$n(1-p)$个观察值大于或等于$x_{p}$."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 样本分位数的求解步骤：\n",
     "> - 1. 将$x_{1}, x_{2}, \\cdots, x_{n}$按自小到大的次序排列成$x_{(1)}\\le x_{(2)}\\le \\cdots\\le x_{(n)}$\n",
     "> - 2. 使用下述公式计算$x_{p}$分位数$$x_{p}=\\left \\{ \\begin{aligned} &x_{([np]+1)}, &当np不是整数\\\\&\\frac{1}{2}[x_{(np)}+x_{(np+1)}], &当np是整数 \\end{aligned}\\right.$$其中，$[\\cdot]$表示取整。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 特别地，当$p=0.25$时，$0.25$分位数$x_{0.25}$也记为$Q_{1}$, 称为第一四分位数；当$p=0.5$时，$0.5$分位数$x_{0.5}$也记为$Q_{2}或M$，称为样本中位数；当$p=0.75$时，$0.75$分位数$x_{0.75}$也记为$Q_{3}$，称为第三四分位数。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> **箱线图的画法**：箱线图基于以下$5$个数字特征概括，即 最小值$Min$、第一四分位数$Q_{1}$、中位数$M$、第三四分位数$Q_{3}$和最大值$Max$。箱线图的形式如下\n",
     "<div align=center>\n",
     "<img src=\"figures/box.jpg\"/>\n",
     "</div>"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🔥例子：以下是$8$个病人的血压(收缩压，$mmHg$)数据，请作出箱线图\n",
     "$$\n",
     "110 \\quad 102 \\quad 117 \\quad 122 \\quad 118 \\quad 150 \\quad 132 \\quad 123\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🦊解：\n",
     "1. 排序\n",
     "$$\n",
     "102 \\quad 110 \\quad 117 \\quad 118 \\quad 122 \\quad 123 \\quad 132 \\quad 150\n",
     "$$\n",
     "\n",
     "2. 计算各分位点及最小最大值\n",
     "$$\n",
     "\\begin{aligned}\n",
     "&\\because np=8\\times 0.25 = 2, \\quad &\\therefore Q_{1}=\\frac{1}{2}(110+117)=113.5 \\\\\n",
     "&\\because np=8\\times 0.2=5 = 4, \\quad &\\therefore Q_{2}=\\frac{1}{2}(118+122)=120 \\\\\n",
     "&\\because np=8\\times 0.75 = 6, \\quad &\\therefore Q_{3}=\\frac{1}{2}(123+132)=127.5 \\\\\n",
     "& Min = 110, Max = 123.\n",
     "\\end{aligned}\n",
     "$$\n",
     "3. 画图"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码(画箱线图）"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 3,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
      },
      "metadata": {
       "needs_background": "light"
      },
      "output_type": "display_data"
     },
     {
      "data": {
       "text/plain": [
        "<Figure size 432x288 with 0 Axes>"
       ]
      },
      "metadata": {},
      "output_type": "display_data"
     }
    ],
    "source": [
     "import matplotlib.pyplot as plt \n",
     "%matplotlib inline \n",
     "plt.rcParams['font.sans-serif']=['SimHei','Songti SC','STFangsong']\n",
     "plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号\n",
     "\n",
     "x = [102, 110, 117, 118, 122, 123, 132, 150]\n",
     "\n",
     "# 程序会自动找出异常点，即相差太大的点，该点< Q1-1.5(Q3-Q1)=Q1-1.5IQR 或> Q3+1.5(Q3-Q1)=Q3+1.5IQR\n",
     "fig, ax = plt.subplots()\n",
     "plt.figure(figsize=(6,4))\n",
     "ax.boxplot(x)\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 1.3 统计量与三大抽样分布"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 统计量：设$X_{1}, X_{2}, \\cdots, X_{n}$是来自总体$X$的一个样本，$g(X_{1}, X_{2}, \\cdots, X_{n})$是$X_{1}, X_{2}, \\cdots, X_{n}$的函数，若$g$中不含任何未知参数，则称$g(X_{1}, X_{2}, \\cdots, X_{n})$是一个**统计量**。\n",
     "> 常用统计量，设$X_{1}, X_{2}, \\cdots, X_{n}$是来自总体$X$的一个样本，$x_{1}, x_{2}, \\cdots, x_{n}$是这一样本的观察值。\n",
     "> - 1. 样本均值$$\\overline{X} = \\frac{1} {n} \\sum_{i=1}^{n}X_{i}$$对应的观察值为$\\overline{x} = \\frac{1} {n} \\sum_{i=1}^{n}x_{i}$\n",
     "> - 2. 样本方差$$\\begin{aligned} &1) S_{n}^{2} = \\frac{1} {n} \\sum_{i=1}^{n}(X_{i} - \\overline{X})^{2} \\\\ &2) S^{2} = \\frac{1} {n-1} \\sum_{i=1}^{n}(X_{i} - \\overline{X})^{2}, 无偏方差，应用较多\\end{aligned}$$对应的观察值分别为$s_{n}^{2} = \\frac{1} {n} \\sum_{i=1}^{n}(x_{i} - \\overline{x})^{2}和s^{2} = \\frac{1} {n-1} \\sum_{i=1}^{n}(x_{i} - \\overline{x})^{2}$\n",
     "> - 3. 样本标准差$$S = \\sqrt{S^{2}} = \\sqrt{\\frac{1} {n-1} \\sum_{i=1}^{n}(X_{i} - \\overline{X})^{2}}$$对应的观察值为$s = \\sqrt{\\frac{1} {n-1} \\sum_{i=1}^{n}(x_{i} - \\overline{x})^{2}}$\n",
     "> - 4. 样本$k$阶（原点）矩$$A_{k} = \\frac{1}{n}\\sum_{i=1}^{n}X_{i}^{k}, k =1, 2, \\cdots$$对应的观察值为$a_{k} = \\frac{1}{n}\\sum_{i=1}^{n}x_{i}^{k}, k =1, 2, \\cdots$\n",
     "> - 5. 样本$k$阶中心矩$$B_{k} = \\frac{1}{n}\\sum_{i=1}^{n}(X_{i} - \\overline{X})^{k}, k =1, 2, \\cdots$$对应的观察值为$b_{k} = \\frac{1}{n}\\sum_{i=1}^{n}(x_{i} - \\overline{x})^{k}, k =1, 2, \\cdots$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 三大抽样分布\n",
     "\n",
     "&emsp;&emsp; (1) $\\chi ^{2}$分布：设$X_{1}, X_{2}, \\cdots, X_{n}$是来自总体$N(0, 1)$的样本，则称统计量\n",
     "$$\\chi ^{2} = X_{1}^{2} + X_{2}^{2} + \\cdots + X_{n}^{2}$$\n",
     "服从自由度为$n$的$\\chi ^{2}$分布，记为$\\chi ^{2} \\sim \\chi ^{2}(n)$。 自由度表示上式中右端包含的独立变量的个数。\n",
     "\n",
     "&emsp;&emsp;$\\chi ^{2}$分布的概率密度函数(不需要记)为\n",
     "$$\n",
     "f(y) = \n",
     "\\left \\{ \n",
     "    \\begin{aligned}\n",
     "    & \\frac{1}{2^{n/2}\\Gamma {(n/2})}y^{n/2-1}e^{-y/2}, &y>0 \\\\\n",
     "    & 0, & 其他\n",
     "    \\end{aligned}\n",
     "\\right.\n",
     "$$\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码（$\\chi ^{2}分布的图形$）"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 4,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
      },
      "metadata": {
       "needs_background": "light"
      },
      "output_type": "display_data"
     }
    ],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "%matplotlib inline\n",
     "from scipy.stats import chi2\n",
     "import numpy as np\n",
     "\n",
     "fig, ax = plt.subplots(1, 1)\n",
     "x = np.linspace(0.01, 30, 10000)\n",
     "ax.plot(x, chi2.pdf(x, df=2), '-', label='n = 2')\n",
     "ax.plot(x, chi2.pdf(x, 4), '--', label='n = 4')\n",
     "ax.plot(x, chi2.pdf(x, df=10), '-.', label='n = 10')\n",
     "ax.set_ylim([0, 0.5])\n",
     "ax.set_xlabel(\"y\")\n",
     "ax.set_ylabel(\"f(y)\")\n",
     "ax.legend()\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 720x360 with 3 Axes>"
       ]
      },
      "metadata": {
       "needs_background": "light"
      },
      "output_type": "display_data"
     }
    ],
    "source": [
     "# 利用定理画卡方分布的图形\n",
     "import matplotlib.pyplot as plt\n",
     "%matplotlib inline\n",
     "from scipy.stats import norm, chi2\n",
     "import numpy as np\n",
     "\n",
     "def demonstate_chi(n):\n",
     "    x = 0\n",
     "    for i in range(n):\n",
     "        x += np.square(norm(loc=0, scale=1).rvs(size=10000))\n",
     "    \n",
     "    return x\n",
     "\n",
     "x = np.linspace(0.01, 30, 10000)\n",
     "\n",
     "n_2 = demonstate_chi(2)\n",
     "n_4 = demonstate_chi(4)\n",
     "n_10 = demonstate_chi(10)\n",
     "\n",
     "plt.figure(figsize=(10, 5))\n",
     "plt.subplot(1,3, 1)\n",
     "plt.plot(x, chi2.pdf(x, 2), '-', label='n = 2', c='blue')\n",
     "plt.hist(n_2, density=True, histtype='stepfilled', alpha=0.5)\n",
     "plt.legend()\n",
     "plt.subplot(1,3, 2)\n",
     "plt.plot(x, chi2.pdf(x, df = 4), '--', label='n = 4', c='gray')\n",
     "plt.hist(n_4, density=True, histtype='stepfilled', alpha=0.5)\n",
     "plt.legend()\n",
     "plt.subplot(1,3, 3)\n",
     "plt.plot(x, chi2.pdf(x, 10), '-.', label='n = 10', c='red')\n",
     "plt.hist(n_10, density=True, histtype='stepfilled', alpha=0.5)\n",
     "plt.legend()\n",
     "plt.tight_layout(w_pad=3)\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> $\\chi ^{2}$分布的性质\n",
     "> - 1. $\\chi ^{2}$分布的**可加性**：设$\\chi_{1}^{2} \\sim \\chi ^{2}(n1), \\chi_{2}^{2} \\sim \\chi ^{2}{n2}$，且$\\chi_{1}^{2}, \\chi_{2}^{2}$相互独立，则$$\\chi_{1}^{2} + \\chi_{2}^{2} \\sim \\chi ^{2} (n1 + n2)$$\n",
     "> - 2. $\\chi ^{2}$分布的**期望**和**方差**:若$\\chi ^{2} \\sim \\chi ^{2}(n)$，则$$E(\\chi ^{2}) = n, D(\\chi ^{2}) = 2n$$ 证：$$\\begin{aligned} &\\chi ^{2} = X_{1}^{2} + X_{2}^{2} + \\cdots + X_{n}^{2}, X_{i} \\sim N(0, 1) \\\\ & 故 E(X_{i})=0, E(X_{i}^{2}) = D(X_{i}) = 1 \\\\ & E(\\chi ^{2}) = \\sum_{i=1}^{n}E(X_{i}^{2}) = n  \\\\ &D(X_{i}^{2}) = E(X_{i}^{4}) - E^{2}(X_{i}^{2}) = 3 - 1 = 2 \\\\ & D(\\chi ^{2}) = \\sum_{i=1}^{n}D(X_{i}^{2}) = 2n\\end{aligned}$$\n",
     "> - 3. $\\chi ^{2}$分布的**分位点**：对于给定的正数$\\alpha, 0 <\\alpha <1$，称满足条件$$P\\{\\chi^{2} > \\chi_{\\alpha} ^{2}(n)\\} = \\int_{\\chi_{\\alpha} ^{2}(n)}^{\\infty}f(y)dy = \\alpha$$ 的点$\\chi_{\\alpha} ^{2}(n)$为$\\chi ^{2}(n)$分布上的$\\alpha$分位点。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "&emsp;&emsp; (2) $t$ 分布：设$X \\sim N(0, 1), Y \\sim \\chi^{2}(n)$，且$X, Y$相互独立，则称随机变量\n",
     "$$\n",
     "t = \\frac{X}{\\sqrt{Y/n}}\n",
     "$$\n",
     "服从自由度为$n$的$t$分布，记为$t \\sim t(n)$。\n",
     "\n",
     "&emsp;&emsp;$t$分布的概率密度函数为：\n",
     "$$\n",
     "h(t) = \\frac{\\Gamma [(n+1)/2]}{\\sqrt{\\pi n} \\Gamma (n/2)}(1 + \\frac{t^{2}}{n})^{-(n+1)/2}, -\\infty < t < \\infty\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码（画$t$分布的图像）"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
      },
      "metadata": {
       "needs_background": "light"
      },
      "output_type": "display_data"
     }
    ],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "%matplotlib inline\n",
     "from scipy.stats import t\n",
     "import numpy as np\n",
     "\n",
     "fig, ax = plt.subplots(1, 1)\n",
     "x = np.linspace(-10, 10, 10000)\n",
     "ax.plot(x, t.pdf(x, df=2), '-', label='n = 2', c='blue')\n",
     "ax.plot(x, t.pdf(x, 9), '--', label='n = 9', c='gray')\n",
     "ax.plot(x, t.pdf(x, df=10000), '-.', label='n = 10000', c='red')\n",
     "ax.set_xlabel(\"t\")\n",
     "ax.set_ylabel(\"h(t)\")\n",
     "ax.legend()\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 7,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 720x360 with 3 Axes>"
       ]
      },
      "metadata": {
       "needs_background": "light"
      },
      "output_type": "display_data"
     }
    ],
    "source": [
     "# 利用定理画 t 分布的分布函数\n",
     "import matplotlib.pyplot as plt\n",
     "%matplotlib inline\n",
     "from scipy.stats import norm, chi2\n",
     "import numpy as np\n",
     "\n",
     "def demonstate_t(n):\n",
     "    x = 0\n",
     "    y = 0\n",
     "    x = norm(loc=0, scale=1).rvs(size=10000)\n",
     "    y = chi2.rvs(df=n)\n",
     "    t = x / np.sqrt(y/ n)\n",
     "    \n",
     "    return t\n",
     "\n",
     "x = np.linspace(-10, 10, 10000)\n",
     "\n",
     "n_2 = demonstate_t(2)\n",
     "n_9 = demonstate_t(9)\n",
     "n_10000 = demonstate_t(10000)\n",
     "\n",
     "plt.figure(figsize=(10, 5))\n",
     "plt.subplot(1,3, 1)\n",
     "plt.plot(x, t.pdf(x, 2), '-', label='n = 2', c='blue')\n",
     "plt.hist(n_2,bins=15, density=True, histtype='stepfilled', alpha=0.5)\n",
     "plt.legend()\n",
     "plt.subplot(1,3, 2)\n",
     "plt.plot(x, t.pdf(x, df = 9), '--', label='n = 9', c='gray')\n",
     "plt.hist(n_9, density=True, histtype='stepfilled', alpha=0.5)\n",
     "plt.legend()\n",
     "plt.subplot(1,3, 3)\n",
     "plt.plot(x, t.pdf(x, 10000), '-.', label='n = 10000', c='red')\n",
     "plt.hist(n_10000, density=True, histtype='stepfilled', alpha=0.5)\n",
     "plt.legend(loc=\"upper right\")\n",
     "plt.tight_layout(w_pad=3)\n",
     "plt.show()\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 当$n \\rightarrow \\infty$时，$t$分布近似为$N(0 ,1)$分布。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> - $t$分布的分位点：对于给定的正数$\\alpha, 0 <\\alpha <1$，称满足条件$$P\\{t > t_{\\alpha}(n)\\} = \\int_{t_{\\alpha}(n)}^{\\infty}h(t)dt = \\alpha$$ 的点$t_{\\alpha}(n)$为$t(n)$分布上的$\\alpha$分位点。\n",
     "> - $h(t)$图形具有对称性，即$t_{1 - \\alpha}(n) = -t_{\\alpha}(n)$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "&emsp;&emsp; (3) $F$ 分布：设$U \\sim \\chi ^{2}(n1), V \\sim \\chi ^{2}(n2)$，且$U, V$相互独立，则称随机变量\n",
     "$$\n",
     "F = \\frac{U/n1}{V/n2}\n",
     "$$\n",
     "服从自由度为$(n1, n2)$的$F$分布，记为$F \\sim F(n1, n2)$。\n",
     "\n",
     "&emsp;&emsp;$F$分布的概率密度函数为：\n",
     "$$\n",
     "\\psi (y) = \n",
     "\\left \\{\n",
     "    \\begin{aligned}\n",
     "    & \\frac{\\Gamma [(n1 +n2)/2](n1/n2)^{n1/2}y^{(n1/2)-1}}{\\Gamma (n1/2)\\Gamma (n2/2)[1+(n1y/n2)]^{(n1+n2)/2}}, &y>0 \\\\\n",
     "    & 0, &其它\n",
     "    \\end{aligned}\n",
     "\\right.\n",
     "$$\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码(画$F$分布函数)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 8,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 432x288 with 1 Axes>"
       ]
      },
      "metadata": {
       "needs_background": "light"
      },
      "output_type": "display_data"
     }
    ],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "%matplotlib inline\n",
     "from scipy.stats import f\n",
     "import numpy as np\n",
     "\n",
     "fig, ax = plt.subplots(1, 1)\n",
     "x = np.linspace(0.01, 10, 10000)\n",
     "ax.plot(x, f.pdf(x, dfn=10, dfd=40), '-', label='F~(10, 40)', c='blue')\n",
     "ax.plot(x, f.pdf(x, dfn=40, dfd=10), '--', label='F~(40, 10)', c='orange')\n",
     "ax.plot(x, f.pdf(x, dfn=11, dfd=3), '-.', label='F~(11, 3)', c='red')\n",
     "ax.set_xlabel(\"y\")\n",
     "ax.set_ylabel(\"f(y)\")\n",
     "ax.legend()\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 720x360 with 3 Axes>"
       ]
      },
      "metadata": {
       "needs_background": "light"
      },
      "output_type": "display_data"
     }
    ],
    "source": [
     "# 利用定理\n",
     "import matplotlib.pyplot as plt\n",
     "%matplotlib inline\n",
     "from scipy.stats import chi2\n",
     "import numpy as np\n",
     "\n",
     "def demonstate_f(n1, n2):\n",
     "    u = 0\n",
     "    v = 0\n",
     "    u = chi2.rvs(df=n1, size=10000)\n",
     "    v = chi2.rvs(df=n2, size=10000)\n",
     "    f = (u/n1) / (v/n2)\n",
     "    \n",
     "    return f\n",
     "\n",
     "x = np.linspace(0.01, 10, 10000)\n",
     "\n",
     "n_10_40 = demonstate_f(10, 40)\n",
     "n_40_10 = demonstate_f(40 ,10)\n",
     "n_11_3 = demonstate_f(11, 3)\n",
     "\n",
     "plt.figure(figsize=(10, 5))\n",
     "plt.subplot(1,3, 1)\n",
     "plt.plot(x, f.pdf(x, dfn=10, dfd=40), '-', label='F~(10, 40)', c='blue')\n",
     "plt.hist(n_10_40, bins=300, density=True, histtype='stepfilled', alpha=0.5)\n",
     "plt.legend()\n",
     "plt.subplot(1,3, 2)\n",
     "plt.plot(x, f.pdf(x, dfn=40, dfd=10), '--', label='F~(40, 10)', c='orange')\n",
     "plt.hist(n_40_10, bins=300, density=True, histtype='stepfilled', alpha=0.5)\n",
     "plt.legend()\n",
     "plt.subplot(1,3, 3)\n",
     "plt.plot(x, f.pdf(x, dfn=11, dfd=3), '-.', label='F~(11, 3)', c='red')\n",
     "plt.hist(n_11_3,bins=550, density=True, histtype='stepfilled', alpha=0.5)\n",
     "plt.xlim([0, 10])\n",
     "plt.legend(loc=\"upper right\")\n",
     "plt.tight_layout(w_pad=3)\n",
     "plt.show()\n",
     "\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> - $F$分布的分位点：对于给定的正数$\\alpha, 0 <\\alpha <1$，称满足条件$$P\\{F > F_{\\alpha}(n1, n2)\\} = \\int_{F_{\\alpha}(n1, n2)}^{\\infty}\\psi (y)dy = \\alpha$$ 的点$F_{\\alpha}(n1, n2)$为$F(n1, n2)$分布上的$\\alpha$分位点。\n",
     "> - 若$F \\sim F(n1, n2)$，则$$\\frac{1}{F} \\sim F(n2, n1)$$\n",
     "> - $F_{1-\\alpha}(n1, n2) =\\frac{1} {F_{\\alpha}(n2, n1)}$。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 📕重要定理：关于正态总体的样本均值与样本方差的分布"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "&emsp;&emsp;**定理一**：设$X_{1}, X_{2}, \\cdots, X_{n}$是来自正态总体$N(\\mu, \\sigma^{2})$的样本，$\\overline{X}$是样本均值，则\n",
     "$$\n",
     "\\overline{X} \\sim N(\\mu, \\sigma^{2}/n).\n",
     "$$\n",
     "\n",
     "&emsp;&emsp;**定理二**：设$X_{1}, X_{2}, \\cdots, X_{n}$是来自正态总体$N(\\mu, \\sigma^{2})$的样本，$\\overline{X} {和} S^{2}$分别是样本均值和样本方差，则有\n",
     "$$\n",
     "\\begin{aligned}\n",
     "& 1. \\frac{(n-1)S^{2}}{\\sigma^{2}} \\sim \\chi^{2}(n-1) \\\\\n",
     "& 2. \\overline{X}与S^{2}相互独立\n",
     "\\end{aligned}\n",
     "$$\n",
     "\n",
     "&emsp;&emsp;**定理三**：设$X_{1}, X_{2}, \\cdots, X_{n}$是来自正态总体$N(\\mu, \\sigma^{2})$的样本，$\\overline{X} {和} S^{2}$分别是样本均值和样本方差，则有\n",
     "$$\n",
     "\\frac{\\overline{X} - \\mu}{S/\\sqrt{n}} \\sim t(n-1).\n",
     "$$\n",
     "\n",
     "&emsp;&emsp;**定理四**：设$X_{1}, X_{2}, \\cdots, X_{n1}{和}Y_{1}, Y_{2}, \\cdots, Y_{n2}$分别是来自正态总体$N(\\mu_1, \\sigma_{1}^{2})和N(\\mu_2, \\sigma_{2}^{2})$的样本，且这两个样本相互独立，则有\n",
     "$$\n",
     "\\begin{aligned}\n",
     "& 1. \\frac{S_{1}^{2}/S_{2}^{2}}{\\sigma_{1}^{2}/\\sigma_{2}^{2}} \\sim F(n1-1, n2-1) \\\\\n",
     "& 2. 当\\sigma_{1}^{2} = \\sigma_{2}^{2} = \\sigma^{2}时，\\frac{(\\overline{X} - \\overline{Y}) - (\\mu_{1} - \\mu_{2})}{S_{w}\\sqrt{\\frac{1}{n1}+\\frac{1}{n2}}} \\sim t(n1+n2-2) \n",
     "\\end{aligned}\n",
     "$$\n",
     "其中，$S_{w}^{2} = \\frac{(n1-1)S_{1}^{2}+(n2-1)S_{2}^{2}}{n1+n2-2}$."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码(验证定理)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 10,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 720x576 with 4 Axes>"
       ]
      },
      "metadata": {
       "needs_background": "light"
      },
      "output_type": "display_data"
     }
    ],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "%matplotlib inline\n",
     "from scipy.stats import chi2, t, norm, f\n",
     "import numpy as np\n",
     "\n",
     "def theory_1(mu, sigma, n):\n",
     "    x_mean = []\n",
     "    for i in range(10000):\n",
     "        x_mean.append(np.sum(norm.rvs(loc=mu, scale=sigma, size=n))/n)\n",
     "    return x_mean\n",
     "\n",
     "def theory_2(mu, sigma, n):\n",
     "    res = []\n",
     "    for i in range(10000):\n",
     "        x = norm.rvs(loc=mu, scale=sigma, size=n)\n",
     "        x_mean = np.mean(x)\n",
     "        s2 = np.sum(np.square(x - x_mean))/(n-1)\n",
     "        res.append((n-1)*s2/(sigma**2))\n",
     "    return res\n",
     "\n",
     "def theory_3(mu, sigma, n):\n",
     "    res = []\n",
     "    for i in range(10000):\n",
     "        x = norm.rvs(loc=mu, scale=sigma, size=n)\n",
     "        x_mean = np.mean(x)\n",
     "        s = np.sqrt(np.sum(np.square(x - x_mean))/(n-1))\n",
     "        res.append((x_mean-mu)/(s/np.sqrt(n)))\n",
     "    return res\n",
     "\n",
     "def theory_4(mu1, mu2, sigma1, sigma2, n1, n2):\n",
     "    res = []\n",
     "    for i in range(10000):\n",
     "        x1 = norm.rvs(loc=mu1, scale=sigma1, size=n1)\n",
     "        x1_mean = np.mean(x1)\n",
     "        x2 = norm.rvs(loc=mu2, scale=sigma2, size=n2)\n",
     "        x2_mean = np.mean(x2)\n",
     "        s1_2 = np.sum(np.square(x1-x1_mean)) / (n1-1)\n",
     "        s2_2 = np.sum(np.square(x2-x2_mean)) / (n2-1)\n",
     "        temp1 = (s1_2/s2_2)\n",
     "        temp2 = (sigma1**2/sigma2**2)\n",
     "        res.append(temp1/temp2)\n",
     "    return res \n",
     "\n",
     "mu = 5\n",
     "sigma = 10\n",
     "n = 5\n",
     "mu1, mu2 = 1, 2\n",
     "sigma1, sigma2 = 3, 4\n",
     "n1, n2 = 10, 40\n",
     "x_mean = theory_1(mu, sigma, n)\n",
     "t2 = theory_2(mu, sigma, n)\n",
     "t_ = theory_3(mu, sigma, n)\n",
     "f_ = theory_4(mu1, mu2, sigma1, sigma2, n1, n2)\n",
     "\n",
     "x1 =np.linspace(-10, 20, 10000)\n",
     "x2 = np.linspace(0.01, 30, 10000)\n",
     "x3 = np.linspace(-5, 5, 10000)\n",
     "x4 = np.linspace(0.01, 10, 10000)\n",
     "\n",
     "plt.figure(figsize=(10, 8))\n",
     "plt.subplot(2,2, 1)\n",
     "plt.plot(x1, norm.pdf(x1,loc=mu, scale=sigma/np.sqrt(n)), '-', label='N({}, {})'.format(mu, sigma**2/n), c='blue')\n",
     "plt.hist(x_mean,bins=50, density=True, histtype='stepfilled', alpha=0.5)\n",
     "plt.title(\"Theory_1\")\n",
     "plt.xlabel(\"x\")\n",
     "plt.ylabel(\"p(x)\")\n",
     "plt.legend()\n",
     "plt.subplot(2,2, 2)\n",
     "plt.plot(x2, chi2.pdf(x2, df=n-1), '--', label='X({})'.format(n-1), c='orange')\n",
     "plt.hist(t2, bins=50,  density=True, histtype='stepfilled', alpha=0.5)\n",
     "plt.title(\"Theory_2\")\n",
     "plt.xlabel(\"x\")\n",
     "plt.ylabel(\"p(x)\")\n",
     "# plt.xlim([0, 30])\n",
     "plt.legend()\n",
     "plt.subplot(2,2, 3)\n",
     "plt.plot(x3, t.pdf(x3, df=n-1), '-.', label='t({})'.format(n-1), c='red')\n",
     "plt.hist(t_,bins=50, density=True, histtype='stepfilled', alpha=0.5)\n",
     "plt.title(\"Theory_3\")\n",
     "plt.xlabel(\"x\")\n",
     "plt.ylabel(\"p(x)\")\n",
     "plt.legend(loc=\"upper right\")\n",
     "plt.subplot(2,2, 4)\n",
     "plt.plot(x4, f.pdf(x4, dfn=n1-1, dfd=n2-1), '--', label='F({}, {})'.format(n1-1, n2-1), c='orange')\n",
     "plt.hist(f_, bins=50, density=True, histtype='stepfilled', alpha=0.5)\n",
     "plt.title(\"Theory_4\")\n",
     "plt.xlabel(\"x\")\n",
     "plt.ylabel(\"p(x)\")\n",
     "plt.xlim([0, 10])\n",
     "plt.legend()\n",
     "\n",
     "plt.tight_layout(w_pad=3)\n",
     "plt.show()"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 1.4 参数估计之点估计的概念"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 点估计：设总体$X$的分布函数$F(x;\\theta)$的形式为已知，$\\theta$是待估计参数，$X_{1}, X_{2}, \\cdots, X_{n}$是$X$的一个样本，$x_{1}, x_{2}, \\cdots, x_{n}$是相应的一个样本值，点估计问题就是要构造一个适当的统计量$\\hat{\\theta}(X_{1}, X_{2}, \\cdots, X_{n})$，用它的观察值$\\hat{\\theta}(x_{1}, x_{2}, \\cdots, x_{n})$作为未知参数$\\theta$的近似值。称$\\hat{\\theta}(X_{1}, X_{2}, \\cdots, X_{n})$为$\\theta$的**估计量**，$\\hat{\\theta}(x_{1}, x_{2}, \\cdots, x_{n})$为$\\theta$的**估计值**。统称它们为**估计**，简记为$\\hat{\\theta}$。\n",
     "> 点估计就是用样本统计量去估计总体分布的未知参数。由于估计量是样本的函数，因此，对于不同的样本值，$\\theta$的估计值一般是不相同的。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 1.5 参数估计之点估计的方法：矩估计"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 矩估计法：设$X$为连续型随机变量，其概率密度为$f(x;\\theta_{1},\\theta_{2}, \\cdots, \\theta_{k})$，或$X$为离散随机变量，其分布律为$P\\{X=x\\}=p(x;\\theta_{1},\\theta_{2}, \\cdots, \\theta_{k})$，其中$\\theta_{1},\\theta_{2}, \\cdots, \\theta_{k}$为待估计参数，$X_{1}, X_{2}, \\cdots, X_{n}$是来自$X$的样本。假设总体$X$的前$k$阶矩\n",
     "$$\n",
     "\\mu_{l} = E(X^{l}) = \\int_{-\\infty}^{\\infty}x^{l}f(x;\\theta_{1},\\theta_{2}, \\cdots, \\theta_{k})dx\n",
     "$$\n",
     "或\n",
     "$$\n",
     "\\mu_{l} = E(X^{l}) = =\\sum x^{l}p(x;\\theta_{1},\\theta_{2}, \\cdots, \\theta_{k})\n",
     "$$\n",
     "**然后假设样本$k$阶矩$A_{k}$等于总体$k$阶矩$\\mu_{k}$，即$A_{k} = \\mu_{k}$**，这种利用样本矩估计总体矩，从而估计未知参数的方法称为**矩估计法**。\n",
     "> 样本矩公式\n",
     "> - 1. 样本原点矩 $$A_{k} = \\frac{1}{n}\\sum_{i=1}^{n}X_{i}^{k}, k =1, 2, \\cdots$$\n",
     "> - 2. 样本中心矩 $$B_{k} = \\frac{1}{n}\\sum_{i=1}^{n}(X_{i} - \\overline{X})^{k}, k =1, 2, \\cdots$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 矩估计法的解题步骤：\n",
     "> - 1. 确定总体分布待估计参数$\\theta_{i}$的个数$n$\n",
     "> - 2. 列出总体分布的前$n$阶矩$\\mu_{1}到\\mu_{n}$，$\\mu_{n}$是关于待估计参数$\\theta_{i}$的函数\n",
     "> - 3. 将$\\mu_{1}到\\mu_{n}$联立方程组，求解待估计参数$\\theta_{i}$\n",
     "> - 4. 将求得的$\\theta_{i}$中的$\\mu_{k}$换成相应的$A_{k}$，即得到待估计参数的估计值"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🔥例子：设总体$X$在$[a, b]$上服从均匀分布，$a, b$未知，$X_{1}, X_{2}, \\cdots, X_{n}$是来自总体$X$的样本，求$a, b$的矩估计量。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🦊解：   \n",
     "1. 确定估计参数个数，$a, b$, $n=2$\n",
     "2. 求总体的前$2$阶矩\n",
     "$$\n",
     "\\begin{aligned}\n",
     "&\\mu_{1} = E(X) = \\frac{b-a}{2} \\\\\n",
     "&\\mu_{2} = E(X^{2}) = D(X) + E^{2}(X) = \\frac{(b-a)^{2}}{12} + \\frac{(b-a)^{2}}{4} \\\\\n",
     "\\end{aligned}\n",
     "$$\n",
     "3. 联立方程组并求解\n",
     "$$\n",
     "\\left \\{\n",
     "\\begin{aligned}\n",
     "&\\mu_{1} = \\frac{b-a}{2} \\\\\n",
     "&\\mu_{2} =  \\frac{(b-a)^{2}}{12} + \\frac{(b-a)^{2}}{4} \\\\\n",
     "\\end{aligned}\n",
     "\\right.\n",
     "$$\n",
     "解得\n",
     "$$\n",
     "a = \\mu_{1} - \\sqrt{3(\\mu_{2}-\\mu_{1}^{2})}, b = \\mu_{1} + \\sqrt{3(\\mu_{2}-\\mu_{1}^{2})}\n",
     "$$\n",
     "4. 将相应的$\\mu_{k}$换成$A_{k}$\n",
     "$$\n",
     "\\begin{aligned}\n",
     "&a = A_{1} - \\sqrt{3(A_{2}-A_{1}^{2})} = \\frac{1}{n}\\sum_{i=1}^{n}X_{i} - \\sqrt{3(\\frac{1}{n}\\sum_{i=1}^{n}X_{i}^{2}-(\\frac{1}{n}\\sum_{i=1}^{n}X_{i})^{2})} \\\\\n",
     "& b = A_{1} + \\sqrt{3(A_{2}-A_{1}^{2})} = \\frac{1}{n}\\sum_{i=1}^{n}X_{i} + \\sqrt{3(\\frac{1}{n}\\sum_{i=1}^{n}X_{i}^{2}-(\\frac{1}{n}\\sum_{i=1}^{n}X_{i})^{2})}\n",
     "\\end{aligned}\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码(求解上题)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 11,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "a的真实值：1, b的真实值：6\n",
       "a的矩估计值：1.08, b的矩估计值：6.07\n"
      ]
     }
    ],
    "source": [
     "import numpy as np\n",
     "from scipy.stats import uniform\n",
     "\n",
     "a_real = 1\n",
     "b_real = 6\n",
     "n = 1000\n",
     "x = uniform.rvs(loc=1, scale=5, size=n)\n",
     "\n",
     "A1 = np.sum(x) / n\n",
     "A2 = np.sum(np.square(x)) / n\n",
     "\n",
     "a_estimate = A1 - np.sqrt(3 *(A2-A1**2))\n",
     "b_estimate = A1 + np.sqrt(3 *(A2-A1**2))\n",
     "print(\"a的真实值：{}, b的真实值：{}\".format(a_real, b_real))\n",
     "print(\"a的矩估计值：{:.2f}, b的矩估计值：{:.2f}\".format(a_estimate, b_estimate))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 1.6 参数估计之点估计的方法：极大似然估计"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 最大似然估计法：\n",
     "\n",
     "&emsp;&emsp;对于离散型随机变量:设其分布律为$P\\{X=s\\}=p(x;\\theta), \\theta \\in \\Theta$的形式已知，$\\theta$为待估计参数，$\\Theta 是 \\theta$可能取值的范围。设$X_{1}, X_{2}, \\cdots, X_{n}$是来自$X$的样本，则$X_{1}, X_{2}, \\cdots, X_{n}$的联合分布律为\n",
     "$$\n",
     "\\prod{i=1}^{n}p(x_{i};\\theta).\n",
     "$$\n",
     "又设$x_{1}, x_{2}, \\cdots, x_{n}$是相应样本$X_{1}, X_{2}, \\cdots, X_{n}$的样本值。易知样本$X_{1}, X_{2}, \\cdots, X_{n}$取到观察值$x_{1}, x_{2}, \\cdots, x_{n}$的概率，即事件$\\{X_{1}=x_{1}, X_{2}=x_{2}, \\cdots, X_{n}=x_{n}\\}$发生的概率为\n",
     "$$\n",
     "L(\\theta) = L(x_{1}, x_{2}, \\cdots, x_{n}; \\theta) = \\prod{i=1}^{n}p(x_{i};\\theta), \\theta \\in \\Theta.\n",
     "$$\n",
     "这一概率随$\\theta$的取值而变化，它是$\\theta$的函数，$L(\\theta)$称为样本的**似然函数**（注意，这里$x_{1}, x_{2}, \\cdots, x_{n}$是已知的样本值，即常数）。\n",
     "\n",
     "最大似然估计思想：固定样本观察值$x_{1}, x_{2}, \\cdots, x_{n}$，在$\\theta$取值的可能范围$\\Theta$内挑选使似然函数$L(x_{1}, x_{2}, \\cdots, x_{n}; \\theta)$达到最大的参数$\\hat{\\theta}$，作为参数$\\theta$的估计值。即取$\\hat{\\theta}$使\n",
     "$$\n",
     "L(x_{1}, x_{2}, \\cdots, x_{n}; \\hat{\\theta}) = \\max_{\\theta \\in \\Theta} L(x_{1}, x_{2}, \\cdots, x_{n}; \\theta)\n",
     "$$\n",
     "这样得到的$\\hat{\\theta}$与样本值$x_{1}, x_{2}, \\cdots, x_{n}$有关，记为$\\hat{\\theta}(x_{1}, x_{2}, \\cdots, x_{n})$，称为参数$\\theta$的**最大似然估计值**，相应的统计量$\\hat{\\theta}(X_{1}, X_{2}, \\cdots, X_{n})$称为参数$\\theta$的**最大似然估计量**。\n",
     "\n",
     "&emsp;&emsp;对于连续型随机变量：似然函数\n",
     "$$\n",
     "L(\\theta) = L(x_{1}, x_{2}, \\cdots, x_{n}; \\theta) = \\prod{i=1}^{n}f(x_{i};\\theta)\n",
     "$$\n",
     "$f(x_{i};\\theta)$为连续随机变量的概率密度函数。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 最大似然函数方法的求解步骤\n",
     "> - 1. 确定随机变量的分布律（概率密度）\n",
     "> - 2. 确定似然函数\n",
     "> - 3. 令 $\\frac{d}{d\\theta}L(\\theta) = 0$，求驻点，便可以找到使$L(\\theta)$取极值的估计参数$\\hat{\\theta}$\n",
     "> - 4. 对于$L(\\theta)$函数中存在大量连乘项或指数项时，可令$\\frac{d}{d\\theta}ln L(\\theta) = 0$，也可以求得$\\hat{\\theta}$，因为$ln\\cdot$函数是单调递增函数，对似然函数做$ln\\cdot$变换不会改变原函数的特征。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🔥例子一：设$X\\sim b(1, p)（二项分布）. X_{1}, X_{2}, \\cdots, X_{n}$是来自$X$的一个样本，求参数$p$的最大似然估计。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🦊解：\n",
     "1. 确定随机变量的分布律（概率密度）\n",
     "$$\n",
     "P\\{X=x\\} = p^{x}(1-p)^{1 - x}, x=0, 1\n",
     "$$\n",
     "2. 确定似然函数\n",
     "$$\n",
     "L(p) = \\prod_{i=1}^{n}P\\{X=x_{i}\\} = \\prod_{i=1}^{n}p^{x_{i}}(1-p)^{1 - x_{i}} = p^{\\sum_{i=1}^{n}x_{i}}(1-p)^{\\sum_{i=1}^{n}(1-x_{i})}\n",
     "$$\n",
     "出现连乘，取对数\n",
     "$$\n",
     "ln L(p) = ln[p^{\\sum_{i=1}^{n}x_{i}}(1-p)^{\\sum_{i=1}^{n}(1-x_{i})}] = ln[p^{\\sum_{i=1}^{n}x_{i}}] + ln [(1-p)^{\\sum_{i=1}^{n}(1-x_{i})}] = \\sum_{i=1}^{n}x_{i}ln p + \\sum_{i=1}^{n}(1-x_{i})ln(1-p)\n",
     "$$\n",
     "3. 令$\\frac{d}{dp}ln L(p) = 0$， 解得\n",
     "$$\n",
     "\\hat{p} = \\frac{1}{n}\\sum_{i=1}{n}x_{i} = \\overline{x}\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码（求解上题）"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 12,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "p的真实值：0.4\n",
       "p的最大似然估计值：389/1000\n"
      ]
     }
    ],
    "source": [
     "from sympy import *\n",
     "from sympy.abc import p\n",
     "from scipy.stats import bernoulli\n",
     "\n",
     "p_real = 0.4\n",
     "\n",
     "x = bernoulli.rvs(p_real, size=1000)\n",
     "\n",
     "Lp = p ** sum(x) * (1-p)**sum(1-x)\n",
     "\n",
     "dLp = diff(Lp, p, 1)\n",
     "p_estimate = solve(dLp)\n",
     "# 寻找符合要求的p值\n",
     "for i in p_estimate:\n",
     "    if i > 0 and i < 1:\n",
     "        p_e = i\n",
     "print(\"p的真实值：{}\".format(p_real))\n",
     "print(\"p的最大似然估计值：{}\".format(p_e))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🔥例子二：设$X\\sim N(\\mu, \\sigma^{2}), \\mu, \\sigma^{2}$为未知参数，$x_{1}, x_{2}, \\cdots, x_{n}$是来自$X$的一个样本值，求$\\mu, \\sigma^{2}$的最大似然估计量。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🦊解：\n",
     "1. 确定随机变量的概率密度函数\n",
     "$$\n",
     "f(x;\\mu, \\sigma^{2}) = \\frac{1}{\\sqrt{2\\pi }\\sigma}e^{-\\frac{(x-\\mu)^{2}}{2\\sigma^{2}}}\n",
     "$$\n",
     "2. 确定似然函数\n",
     "$$\n",
     "L(\\mu, \\sigma) = \\prod_{i=1}^{n} f(x_{i};\\mu, \\sigma^{2}) = \\prod_{i=1}^{n}(\\frac{1}{\\sqrt{2\\pi }\\sigma}e^{-\\frac{(x_{i}-\\mu)^{2}}{2\\sigma^{2}}}) = (\\frac{1}{\\sqrt{2\\pi }\\sigma})^{n}e^{-\\sum_{i=1}^{n}\\frac{(x_{i}-\\mu)^{2}}{2\\sigma^{2}}}\n",
     "$$\n",
     "出现指数求和项，整理成对数似然函数\n",
     "$$\n",
     "ln L(\\mu, \\sigma) = ln [(\\frac{1}{\\sqrt{2\\pi }\\sigma})^{n}e^{-\\sum_{i=1}^{n}\\frac{(x_{i}-\\mu)^{2}}{2\\sigma^{2}}}] = -n ln\\sqrt{2\\pi }\\sigma - \\sum_{i=1}^{n}\\frac{(x_{i}-\\mu)^{2}}{2\\sigma^{2}}\n",
     "$$\n",
     "3. 令$\\frac{\\partial }{\\partial \\mu}ln L(\\mu, \\sigma) = 0,  \\frac{\\partial }{\\partial \\sigma}ln L(\\mu, \\sigma) = 0$，建立似然方程组\n",
     "$$\n",
     "\\left \\{\n",
     "\\begin{aligned}\n",
     "&\\frac{\\partial }{\\partial \\mu}ln L(\\mu, \\sigma) = -2 \\sum_{i=1}^{n}\\frac{(x_{i}-\\mu)}{2\\sigma^{2}} = 0 \\\\\n",
     "&\\frac{\\partial }{\\partial \\sigma}ln L(\\mu, \\sigma) = - \\frac{n}{\\sigma} + \\sum_{i=1}^{n}\\frac{(x_{i}-\\mu)^{2}}{\\sigma^{3}} = 0\n",
     "\\end{aligned}\n",
     "\\right.\n",
     "$$\n",
     "4. 解得\n",
     "$$\n",
     "\\left \\{\n",
     "\\begin{aligned}\n",
     "&\\mu = \\frac{1}{n}\\sum_{i=1}^{n}x_{i} \\\\\n",
     "&\\sigma^{2} = \\frac{1}{n}\\sum_{i=1}^{n}(x_{i} - \\mu)^{2}\n",
     "\\end{aligned}\n",
     "\\right.\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码(验证上题结果)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "随机变量的原均值为：2， 方差为：9\n",
       "最大似然估计的均值为：2.01， 方差为：9.39\n"
      ]
     }
    ],
    "source": [
     "from sympy import *\n",
     "from sympy.abc import mu, sigma \n",
     "from scipy.stats import norm\n",
     "\n",
     "mu_real = 2\n",
     "sigma_real = 3\n",
     "n = 1000\n",
     "\n",
     "x = norm.rvs(loc=mu_real, scale=sigma_real, size=n)\n",
     "\n",
     "mu_estimate = sum(x) / n \n",
     "sigma2_estimate = sum((x - mu_estimate)**2) / n\n",
     "\n",
     "print(\"随机变量的原均值为：{}， 方差为：{}\".format(mu_real, sigma_real**2))\n",
     "print(\"最大似然估计的均值为：{:.2f}， 方差为：{:.2f}\".format(mu_estimate,sigma2_estimate))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 💡最大似然估计性质：设$\\theta$的函数$u=u(\\theta), \\theta \\in \\Theta$具有*单值反函数*$\\theta=\\theta(u), u\\in \\vartheta$.又假设$\\hat{\\theta}$是$X$的概率分布中参数$\\theta$的最大似然估计，则$\\hat{u}=\\hat{u}(\\theta)$是$u(\\theta)$的最大似然估计，这一性质称为最大似然估计的**不变性**。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 1.7 估计量的评选标准：无偏性、有效性、相合性（一致性）"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "设$X_{1}, X_{2}, \\cdots, X_{n}$是总体$X$的一个样本，$\\theta \\in \\Theta$是包含在总体$X$的分布中的待估计参数，$\\Theta 是\\theta$的取值范围。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 无偏性：若估计量$\\hat{\\theta} = \\hat{\\theta}(X_{1}, X_{2}, \\cdots, X_{n})$的数学期望$E(\\hat{\\theta})$存在，且对于任意的$\\theta \\in \\Theta$有\n",
     "$$\n",
     "E(\\hat{\\theta}) = \\theta\n",
     "$$\n",
     "则称$\\hat{\\theta}$为$\\theta$的**无偏估计量**。即估计值的期望等于待估计参数的真实值。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 估计量的无偏性是说，对于总体的样本值，由某个估计量得到的估计值与真值存在偏差，但反复将这估计量使用多次得到多个估计值，这多个估计值的期望（平均）与真值之间的偏差$E(\\hat{\\theta})-\\theta$为零。在科学技术中$E(\\hat{\\theta})-\\theta$称为以$E(\\hat{\\theta})$作为$\\theta$的估计的系统误差。无偏估计的实际意义就是无系统误差。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 有效性：假设要比较参数$\\theta$的两个无偏估计量$\\hat{\\theta_{1}}{和}\\hat{\\theta_{2}}$，如果在样本容量$n$相同的情况下，$\\hat{\\theta_{1}}$的观察值较$\\hat{\\theta_{2}}$更密集在真值$\\theta$的附近，则认为$\\hat{\\theta_{1}}{比}\\hat{\\theta_{2}}$更为理想。又由于方差是随机变量取值与其数学期望（此时数学期望$E(\\hat{\\theta_{1}})=E(\\hat{\\theta_{2}}) = \\theta$）的偏离程度的度量。所以无偏估计以方差小者为好。设$\\hat{\\theta_{1}} = \\hat{\\theta_{1}}(X_{1}, X_{2}, \\cdots, X_{n})$与$\\hat{\\theta_{2}} = \\hat{\\theta_{2}}(X_{1}, X_{2}, \\cdots, X_{n})$都是$\\theta$的无偏估计量，若对于任意$\\theta \\in \\Theta$，有\n",
     "$$\n",
     "D(\\hat{\\theta_{1}}) \\le D(\\hat{\\theta_{2}})\n",
     "$$\n",
     "且至少对于某一个$\\theta \\in \\Theta$上式中的不等号成立，则称$\\hat{\\theta_{1}}$较$\\hat{\\theta_{2}}$**有效**。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 相合性（一致性）：设$\\hat{\\theta} = \\hat{\\theta}(X_{1}, X_{2}, \\cdots, X_{n})$为参数$\\theta$的估计量，若对于任意$\\theta \\in \\Theta$，当$n \\rightarrow \\infty$时$\\hat{\\theta} = \\hat{\\theta}(X_{1}, X_{2}, \\cdots, X_{n})$依概率收敛于$\\theta$，则称$\\hat{\\theta}$为$\\theta$的**相合估计量**。即对于任意$\\varepsilon > 0$，有\n",
     "$$\n",
     "\\lim_{n\\rightarrow \\infty}P\\{| \\hat{\\theta} - \\theta| < \\varepsilon\\} = 1\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 1.8 参数估计之区间估计"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 背景：对于一个未知量或未知参数的估计，常不以得到近似值为满足，还需估计误差，即要求知道近似值的精确程度（也就是所求真值的所在范围）。类似地，对于未知参数$\\theta$，除了求出它的点估计$\\hat{\\theta}$外，还希望估计出一个范围，并希望知道这个范围包含参数$\\theta$真值的可信程度。这样的范围通常以区间的形式给出，同时还给出此区间包含参数$\\theta$真值的可信程度，这种形式的估计称为**区间估计**。这样的区间即所谓**置信区间**。\n",
     "\n",
     "* 置信区间：设总体$X$的分布函数$F(x;\\theta)$含有一个未知参数$\\theta, \\theta \\in \\Theta（\\Theta{是}\\theta 可能取值的范围）$，对于给定值$\\alpha（0 < \\alpha < 1）$，若来自$X$的样本$X_{1}, X_{2}, \\cdots, X_{n}$确定的两个统计量$\\underline{\\theta} = \\underline{\\theta}(X_{1}, X_{2}, \\cdots, X_{n}) {和}\\overline{\\theta} = \\overline{\\theta}(X_{1}, X_{2}, \\cdots, X_{n}), (\\underline(\\theta)<\\overline{\\theta})$，对于任意$\\theta \\in \\Theta$满足\n",
     "$$\n",
     "P\\{\\underline{\\theta}(X_{1}, X_{2}, \\cdots, X_{n}) <\\theta <\\overline{\\theta}(X_{1}, X_{2}, \\cdots, X_{n})\\} \\ge 1 -\\alpha\n",
     "$$\n",
     "则称随机区间$(\\underline{\\theta}, \\overline{\\theta})$是$\\theta$置信水平为$1 -\\alpha$的**置信区间**，$\\underline{\\theta} {和} \\overline{\\theta}$分别称为置信水平为$1 -\\alpha$的双侧置信区间的**置信下限和置信上限**，$1 -\\alpha$称为置信水平。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "&emsp;&emsp;上式的含义为：对总体进行多次重复抽样（每次抽样的样本容量相同，均为$n$）,每一次抽样都确定待估计参数的一个区间$(\\underline{\\theta}, \\overline{\\theta})$，每个这样的区间有两种可能，即要么包含待估计的真值$\\theta$，要么不包含待估计的真值$\\theta$。根据大数定理，包含真值$\\theta$的区间数量约占$100(1-\\alpha)\\%$，不包含真值$\\theta$的区间数量约占$100\\alpha \\%$。例如，若$\\alpha=0.01$，反复抽样$1000$次，则得到的$1000$个区间中不包含$\\theta$真值的约为$10$个。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🔥例子：设总体$X \\sim N(\\mu, \\sigma^{2})$，$\\sigma^{2}$为已知，$\\mu$为未知，设$X_{1}, X_{2}, \\cdots, X_{n}$是来自$X$的样本，求$\\mu$的置信水平为$1-\\alpha$的置信区间。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🦊解：\n",
     "\n",
     "由于$\\overline{X}{是}X$的无偏估计，且\n",
     "$$\n",
     "\\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\sim N(0, 1)\n",
     "$$\n",
     "$\\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}}$所服从的分布$N(0, 1)$不依赖于任何未知参数，按标准正态分布的上$\\alpha$分位点定义，有\n",
     "$$\n",
     "P\\left\\{\\left|\\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}}\\right| < z_{\\alpha/2}\\right\\} = 1-\\alpha\n",
     "$$\n",
     "即\n",
     "$$\n",
     "P\\left\\{ \\overline{X} - \\frac{\\sigma}{\\sqrt{n}}z_{\\alpha/2}< \\mu < \\overline{X} + \\frac{\\sigma}{\\sqrt{n}}z_{\\alpha/2}\\right\\} = 1-\\alpha\n",
     "$$\n",
     "由定义知，$\\mu$的一个置信水平为$1-\\alpha$的置信区间为：\n",
     "\n",
     "$$\n",
     "(\\overline{X} - \\frac{\\sigma}{\\sqrt{n}}z_{\\alpha/2}, \\overline{X} + \\frac{\\sigma}{\\sqrt{n}}z_{\\alpha/2})\n",
     "$$\n",
     "或写为\n",
     "$$\n",
     "(\\overline{X} \\pm \\frac{\\sigma}{\\sqrt{n}}z_{\\alpha/2})\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码（通过例题理解置信区间）"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 14,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "在100个置信区间里，有89个置信区间包含未知参数mu\n",
       "包含未知参数mu的置信区间数89>=95.0[区间数x(1-alpha)]\n"
      ]
     },
     {
      "data": {
       "image/png": "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",
       "text/plain": [
        "<Figure size 720x576 with 1 Axes>"
       ]
      },
      "metadata": {
       "needs_background": "light"
      },
      "output_type": "display_data"
     }
    ],
    "source": [
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
     "%matplotlib inline \n",
     "plt.rcParams['font.sans-serif']=['SimHei','Songti SC','STFangsong']\n",
     "plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号\n",
     "from scipy.stats import norm \n",
     "\n",
     "# 令上题中 mu = 0.1 sigma = 1, alpha = 0.05，然后估计 参数 mu 的置信区间\n",
     "\n",
     "def get_confident_interval(mu, sigma, n, interval_num, alpha):\n",
     "    confident_intervals = []\n",
     "    for i in range(interval_num):\n",
     "        x = norm.rvs(loc=mu, scale=sigma, size=n)\n",
     "        # 置信区间上限计算 因为alpha/2 的分位点z_alpha/2 是从负无穷到-z_alpha/2 进行积分，因此得到的分位点需要加一个负号\n",
     "        right = np.sum(x)/n - (sigma/np.sqrt(n))*norm.ppf(loc=mu, scale=sigma, q=alpha/2)\n",
     "        # 置信区间下限计算\n",
     "        left = np.sum(x)/n + (sigma/np.sqrt(n))*norm.ppf(loc=mu, scale=sigma, q=alpha/2)\n",
     "        confident_intervals.append((left, right))\n",
     "    return confident_intervals\n",
     "\n",
     "mu, sigma = 0.1, 1\n",
     "n, alpha = 1000, 0.05\n",
     "interval_num = 100\n",
     "confident_intervals = get_confident_interval(mu, sigma, n, interval_num, alpha)\n",
     "count = 0\n",
     "plt.figure(figsize=(10, 8))\n",
     "for idx, temp in enumerate(confident_intervals):\n",
     "    plt.vlines(x=idx+1, ymin=temp[0], ymax=temp[1])\n",
     "    plt.scatter(x=np.array([idx+1]*2),y=np.array([temp[0], temp[1]]), c='r')\n",
     "    if mu >= temp[0] and mu <= temp[1]:\n",
     "        count += 1\n",
     "\n",
     "\n",
     "print(\"在{}个置信区间里，有{}个置信区间包含未知参数mu\".format(interval_num, count))\n",
     "print(\"包含未知参数mu的置信区间数{}>={}[区间数x(1-alpha)]\".format(count, interval_num*(1-alpha)))\n",
     "plt.axhline(y=0.1, ls='--', c='r')\n",
     "plt.show()\n",
     "\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 寻求未知参数$\\theta$的置信区间的具体步骤：\n",
     "> - 1. 寻求一个**枢轴量$W$**，枢轴量的分布不依赖于参数$\\theta$以及其它未知参数。枢轴量是关于样本$X_{1}, X_{2}, \\cdots, X_{n}$和未知参数$\\theta$的函数，即$W =W(X_{1}, X_{2}, \\cdots, X_{n};\\theta)$，其中$X_{1}, X_{2}, \\cdots, X_{n}$为已知。\n",
     "> - 2. 对于给定的置信水平$1-\\alpha$，定出两个常数$a, b$，使$$P\\left\\{ a <W(X_{1}, X_{2}, \\cdots, X_{n};\\theta) < b\\right \\} = 1-\\alpha $$则$(a, b)$既是未知参数$\\theta$的一个置信水平为$1-\\alpha$置信区间。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🧭表1.8：正态总体均值、方差的置信区间与单侧置信限（置信水平为$1-\\alpha$）\n",
     "\n",
     "| |待估计参数|其他参数|枢轴量的分布|置信区间|单侧置信限|\n",
     "|:---:|:---:|:---:|:---:|:---:|:---:|\n",
     "|一个正态总体|$\\mu$|$\\sigma^{2}已知$|$Z=\\frac{\\bar{X}-\\mu}{\\sigma / \\sqrt{n}} \\sim N(0,1)$|$\\left(\\bar{X} \\pm \\frac{\\sigma}{\\sqrt{n}} z_{a / 2}\\right)$|$\\bar{\\mu}=\\bar{X}+\\frac{\\sigma}{\\sqrt{n}} z_{\\alpha} \\quad \\underline{\\mu}=\\bar{X}-\\frac{\\sigma}{\\sqrt{n}} x_{\\alpha}$|\n",
     "|一个正态总体|$\\mu$|$\\sigma^{2}未知$|$t=\\frac{\\bar{X}-\\mu}{S / \\sqrt{n}} \\sim t(n-1)$|$\\left(\\bar{X} \\pm \\frac{S}{\\sqrt{n}} t_{\\alpha / 2}(n-1)\\right)$|$\\bar{\\mu}=\\bar{X}+\\frac{S}{\\sqrt{n}} t_{\\alpha}(n-1) \\quad \\underline{\\mu}=\\bar{X}-\\frac{S}{\\sqrt{n}} t_{\\alpha}(n-1)$|\n",
     "|一个正态总体|$\\sigma^{2}$|$\\mu未知$|$\\chi^{2} =\\frac{(n-1) S^{2}}{\\sigma^{2}} \\sim \\chi^{2}(n-1)$|$\\left(\\bar{X} \\pm \\frac{S}{\\sqrt{n}} t_{\\alpha / 2}(n-1)\\right)$|$\\overline{\\sigma^{2}}=\\frac{(n-1) S^{2}}{\\chi_{1-\\alpha}^{2}(n-1)} \\quad \\underline{ \\sigma^{2}}=\\frac{(n-1) S^{2}}{\\chi_{\\alpha}^{2}(n-1)}$|\n",
     "|两个正态总体|$\\mu_{1}-\\mu_{2}$|$\\sigma{1}^{2}, \\sigma{2}^{2}已知$|$\\begin{aligned}Z &=\\frac{\\bar{X}-\\bar{Y}-\\left(\\mu_{1}-\\mu_{2}\\right)}{\\sqrt{\\frac{\\sigma_{1}^{2}}{n_{1}}+\\frac{\\sigma_{2}^{2}}{n_{2}}}} \\\\& \\sim N(0,1)\\end{aligned}$|$\\left(\\bar{X}-\\bar{Y} \\pm z_{\\alpha / 2} \\sqrt{\\frac{\\sigma_{1}^{2}}{n_{1}}+\\frac{\\sigma_{2}^{2}}{n_{2}}}\\right)$|$\\begin{aligned}{l}\\overline{\\mu_{1}-\\mu_{2}}=\\bar{X}-\\bar{Y}+z_{\\alpha} \\sqrt{\\frac{\\sigma_{1}^{2}}{n_{1}}+\\frac{\\sigma_{2}^{2}}{n_{2}}}\\\\\\underline{\\mu_{1}-\\mu_{2}}=\\bar{X}=\\bar{Y}-z_{\\alpha} \\sqrt{\\frac{\\sigma_{1}^{2}}{n_{1}}+\\frac{\\sigma_{2}^{2}}{n_{2}}}\\end{aligned}$|\n",
     "|两个正态总体|$\\mu_{1}-\\mu_{2}$|$\\sigma{1}^{2}=\\sigma{2}^{2}=\\sigma^{2}未知$|$\\begin{array}{c}t=\\frac{(\\bar{X}-\\bar{Y})-\\left(\\mu_{1}-\\mu_{2}\\right)}{S_{w} \\sqrt{\\frac{1}{n_{1}}+\\frac{1}{n_{2}}}} \\\\\\sim t\\left(n_{1}+n_{2}-2\\right) \\\\S_{w}^{2}=\\frac{\\left(n_{1}-1\\right) S_{1}^{2}+\\left(n_{2}-1\\right) S_{2}^{2}}{n_{1}+n_{2}-2}\\end{array}$|$\\left(\\bar{X}-\\bar{Y} \\pm t_{\\alpha / 2}\\left(n_{1}+n_{2}-\\right.\\right.2)  \\left.S_{w} \\sqrt{\\frac{1}{n_{1}}+\\frac{1}{n_{2}}}\\right) $|$\\begin{array}{l}\\overline{\\mu_{1}-\\mu_{2}}=\\bar{X}-\\bar{Y} \\\\\\quad+t_{\\alpha}\\left(n_{1}+n_{2}-2\\right) S_{w} \\sqrt{\\frac{1}{n_{1}}+\\frac{1}{n_{2}}} \\\\\\underline{\\mu_{1}-\\mu_{2}}=\\bar{X}-\\bar{Y} \\\\\\quad-t_{\\alpha}\\left(n_{1}+n_{2}-2\\right) S_{w} \\sqrt{\\frac{1}{n_{1}}+\\frac{1}{n_{2}}}\\end{array}$|\n",
     "|两个正态总体|$\\frac{\\sigma{1}^{2}}{\\sigma{2}^{2}}$|$\\mu_{1}, \\mu_{2}未知$|$\\begin{aligned}F &=\\frac{S_{1}^{2} / S_{2}^{2}}{\\sigma_{1}^{2} / \\sigma_{2}^{2}} \\\\& \\sim F\\left(n_{1}-1, n_{2}-1\\right)\\end{aligned}$|$\\begin{array}{c}\\left(\\frac{S_{1}^{2}}{S_{2}^{2}} \\frac{1}{F_{a / 2}\\left(n_{1}-1, n_{2}-1\\right)}\\right. ,\\\\\\left.\\frac{S_{1}^{2}}{S_{2}^{2}} \\frac{1}{F_{1-\\alpha / 2}\\left(n_{1}-1, n_{2}-1\\right)}\\right)\\end{array}$|$\\begin{aligned}&\\frac{\\overline{\\sigma_{1}^{2}}}{\\sigma_{2}^{2}}= \\frac{S_{1}^{2}}{S_{2}^{2}}\\frac{1}{F_{1-\\alpha / 2}\\left(n_{1}-1, n_{2}-1\\right)} \\\\ &\\frac{\\sigma_{1}^{2}}{\\underline{\\sigma_{2}^{2}}} = \\frac{S_{1}^{2}}{S_{2}^{2}} \\frac{1}{F_{a / 2}\\left(n_{1}-1, n_{2}-1\\right)} \\end{aligned}$|"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 1.9 假设检验之基本思想"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 假设检验问题：在总体的分布函数完全未知或只知其形式、但不知其参数的情况下，为了推断总体的某些未知特性，便提出关于总体的假设，例如，假设某糖果车间生产的糖果的均值为$0.5kg$；需要根据已知的样本（例如某一天生产的糖果）对所提出的假设（判断糖果均值是否为$0.5kg$）作出是接受（糖果均值是$0.5kg$）还是拒绝（糖果均值不是$0.5kg$）的决策。假设检验就是做出这一决策的过程。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 🔥引入：某生产葡萄糖车间，袋装糖的质量是一个随机变量，服从正态分布，在车间正常工作时，袋装糖质量的均值为$0.5kg$，标准差为$0.015kg$，某日车间生产了$9$袋葡糖糖，其袋装质量为：\n",
     "$$\n",
     "0.479 \\quad 0.506 \\quad 0.518 \\quad 0.524 \\quad 0.498 \\quad 0.511 \\quad 0.520 \\quad 0.515 \\quad 0.512\n",
     "$$\n",
     "问当日机器是否正常工作？\n",
     "\n",
     "假设标准差是一意已知量，现在要判断当日机器是否正常工作即判断当日所生产的样本的均值是否等于正常工作时的均值即可，于是，提出如下假设\n",
     "$$\n",
     "H_{0}: \\mu = 0.5 ; \\quad H_{1}:\\mu \\ne 0.5\n",
     "$$\n",
     "假设$H_{0}$表示当日生产的样本的均值等于正常工作时的均值，即机器正常工作，假设$H_{1}$表示当日生产的样本的均值不等于正常工作时的均值，即机器不正常工作。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 🦊分析：**如何对上述假设做出决策呢？根据引入知，假设是对未知参数做出假设，要通过样本对未知参数做出的假设进行决策，则需要构造一个关于样本和未知参数的函数，上一节区间估计的计算也有和这里相似的一步，没错，就是枢轴量，可以通过枢轴量将样本和未知参数联系起来，不过在假设检验里将枢轴量称为检验统计量**，在本例中构造检验统计量（枢轴量）\n",
     "$$\n",
     "\\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}}\n",
     "$$\n",
     "其实，只判断$|\\overline{x} - \\mu|$的大小也可以做出做出决策，但取上述的检验统计量会使决策的过程更加简便化。\n",
     "\n",
     "因为，当$H_{0}$为真时，$\\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\sim N(0, 1)$。而判断$|\\overline{x} - \\mu|$的大小也可以转化为判断$\\frac{\\overline{x} - \\mu}{\\sigma/\\sqrt{n}}$的大小。适当选定一正数$k$，使当观察值$\\overline{x}$满足$\\frac{\\overline{x} - \\mu}{\\sigma/\\sqrt{n}}\\ge k$时就拒绝$H_{0}$，反之，$\\frac{\\overline{x} - \\mu}{\\sigma/\\sqrt{n}}< k$，就接受$H_{0}$."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "&emsp;&emsp;然而，由于做出决策的依据是总体中的样本，所以$H_{0}$为真时也可能做出拒绝$H_{0}$的决策(*即做出的决策是错误的决策，例如，判断假设为假的，但实际假设是真的*)，将犯这种错误的概率记为\n",
     "$$\n",
     "P\\{当H_{0}为真时拒绝H_{0}\\} \\quad 或 P_{\\theta}\\{拒绝H_{0}\\}， \\theta 为假设的未知参数\n",
     "$$\n",
     "希望将犯这类错误控制在一定范围内，即给出一个较小的数$\\alpha（0<\\alpha<1）$，使犯这类错误的概率不超过$\\alpha$，即\n",
     "$$\n",
     "P\\{当H_{0}为真时拒绝H_{0}\\} \\le \\alpha\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "&emsp;&emsp;为确定刚才需要选定的正数$k$，允许犯这类错误的最大概率为$\\alpha$，将上式取等号\n",
     "$$\n",
     "P\\{当H_{0}为真时拒绝H_{0}\\} = \\alpha\n",
     "$$\n",
     "则对于例题，即使\n",
     "$$\n",
     "P\\{\\left | \\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\right| \\ge k\\} = \\alpha\n",
     "$$\n",
     "由于$\\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\sim N(0, 1)$，所以$k$取$z_{\\alpha/2}$便于查表。即\n",
     "$$\n",
     "\\left | \\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\right| \\ge k 时\n",
     "$$\n",
     "则拒绝假设$H_{0}$，若\n",
     "$$\n",
     "\\left | \\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\right| < k 时\n",
     "$$\n",
     "则接受假设$H_{0}$，$\\alpha$称为**显著性水平**。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码（检验`引入`例题）"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 15,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "检验统计量1.84 < 1.96, 接受假设H0, 则mu = 0.5, 机器工作正常\n"
      ]
     }
    ],
    "source": [
     "from scipy.stats import norm \n",
     "import numpy as np \n",
     "\n",
     "# 显著性水平 alpha = 0.05\n",
     "# H0: mu = 0.5; H1: mu != 0.5;  \n",
     "# sigma = 0.015\n",
     "\n",
     "x = [0.479, 0.506, 0.518, 0.524, 0.498, 0.511, 0.520, 0.515, 0.512]\n",
     "\n",
     "mu = 0.5\n",
     "sigma = 0.015 \n",
     "alpha = 0.05\n",
     "\n",
     "k = - norm.ppf(loc=0, scale=1, q=alpha/2)\n",
     "check = np.abs((np.mean(x) - mu)/(sigma/np.sqrt(9)))\n",
     "\n",
     "if check >= k:\n",
     "    print(\"检验统计量{:.2f} >= {:.2f}, 拒绝假设H0, 则mu != 0.5, 机器工作不正常\".format(check, k))\n",
     "else:\n",
     "    print(\"检验统计量{:.2f} < {:.2f}, 接受假设H0, 则mu = 0.5, 机器工作正常\".format(check, k))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "&emsp;&emsp;对于上述例题，假设的未知参数$\\theta$为等于或不等于某一假设常量，形如这类的假设检验称为**双边假设检验**。还有一些其它的问题要求假设的未知参数$\\theta$大于等于或小于等于某一假设常量，分别将其称为**左边检验**和**右边检验**"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 左边检验：即检验假设\n",
     "$$\n",
     "H_{0}:\\theta \\le \\theta_{0}; \\quad H_{1}:\\theta > \\theta_{0}\n",
     "$$\n",
     "* 右边检验：即检验假设\n",
     "$$\n",
     "H_{0}:\\theta \\ge \\theta_{0}; \\quad H_{1}:\\theta < \\theta_{0}\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* **讨论单边检验的拒绝域**：\n",
     "\n",
     "🔥(右边检验)设总体$X \\sim N(\\mu, \\sigma^{2})$，$\\mu {未知}, \\sigma {已知}$，$X_{1}, X_{2}, \\cdots, X_{n}$是来自总体$X$的样本，给定显著性书平$\\alpha$，求检验问题\n",
     "$$\n",
     "H_{0}:\\mu \\le \\mu_{0}; \\quad H_{1}:\\mu > \\mu_{0}\n",
     "$$\n",
     "的拒绝域（默认$H_{0}$）。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🦊解：\n",
     "求拒绝域即寻找满足$H_{1}$假设的区间，因$H_{0}$中的$\\mu$都比$H_{1}$中的$\\mu$要小，当拒绝$H_{0}$时，观察值$\\overline{x}$会向假设$H_{1}$靠拢，即观察值$\\overline{x}$会偏大，因此，拒绝域的形式为\n",
     "$$\n",
     "\\overline{x} \\ge k (k为适当正数)\n",
     "$$\n",
     "接下来即确定正数$k$\n",
     "$$\n",
     "\\begin{aligned}\n",
     "P\\left\\{ H_{0}为真时拒绝H_{0}\\right\\} &= P\\left\\{\\overline{X} \\ge k \\right \\} \\\\\n",
     "& = P\\left\\{ \\frac{\\overline{X} - \\mu_{0}}{\\sigma/\\sqrt{n}} \\ge \\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}\\right\\} \\\\ \n",
     "&\\le P\\left\\{ \\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\ge \\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}\\right\\}\n",
     "\\end{aligned}\n",
     "$$\n",
     "上式不等号成立是由于$\\mu \\le \\mu_{0}, \\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\ge \\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}$，事件$\\left\\{ \\frac{\\overline{X} - \\mu_{0}}{\\sigma/\\sqrt{n}} \\ge \\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}\\right \\} \\subset \\left\\{ \\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\ge \\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}\\right \\}$，要控制$P\\{H_{0}为真时拒绝H_{0}\\} \\le \\alpha$，只需令\n",
     "$$\n",
     "P\\left\\{ \\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\ge \\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}\\right\\} = \\alpha\n",
     "$$\n",
     "由于 $\\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\sim N(0, 1)$，则令$\\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}} = z_{\\alpha}$分位点。得检验问题得拒绝域为\n",
     "$$\n",
     "\\overline{x} \\ge k =\\sigma/\\sqrt{n}z_{\\alpha} + \\mu_{0} \\\\\n",
     "$$\n",
     "即\n",
     "$$\n",
     "\\frac{\\overline{x} - \\mu_{0}}{\\sigma/\\sqrt{n}} \\ge z_{\\alpha}\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🔥（左边检验）设总体$X \\sim N(\\mu, \\sigma^{2})$，$\\mu {未知}, \\sigma {已知}$，$X_{1}, X_{2}, \\cdots, X_{n}$是来自总体$X$的样本，给定显著性书平$\\alpha$，求检验问题\n",
     "$$\n",
     "H_{0}:\\mu \\ge \\mu_{0}; \\quad H_{1}:\\mu < \\mu_{0}\n",
     "$$\n",
     "的拒绝域（默认$H_{0}$）。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🦊解：\n",
     "\n",
     "拒绝$H_{0}$时，均值$\\mu$向$H_{1}$靠拢，即$\\mu$的无偏估计$\\overline{x}$较小，取一适当正数$k$，$H_{0}$的拒绝域形式为：\n",
     "$$\n",
     "\\overline{x} \\le k\n",
     "$$\n",
     "\n",
     "当$H_{0}$为真时\n",
     "$$\n",
     "\\frac{\\overline{X}- \\mu_{0}}{\\sigma/\\sqrt{n}} \\sim N(0, 1)\n",
     "$$\n",
     "确定$k$的取值\n",
     "$$\n",
     "\\begin{aligned}\n",
     "P\\left\\{ H_{0}为真时拒绝H_{0}\\right\\} &= P\\left\\{\\overline{x} \\le k\\right\\} \\\\\n",
     "& = P\\left\\{\\frac{\\overline{X}- \\mu_{0}}{\\sigma/\\sqrt{n}} \\le \\frac{\\overline{k}- \\mu_{0}}{\\sigma/\\sqrt{n}}\\right\\} \\\\\n",
     "& \\le P\\left\\{\\frac{\\overline{X}- \\mu}{\\sigma/\\sqrt{n}} \\le \\frac{\\overline{k}- \\mu_{0}}{\\sigma/\\sqrt{n}}\\right\\}, (H_{0}为真时，\\mu \\ge \\mu_{0}) \n",
     "\\end{aligned}\n",
     "$$\n",
     "\n",
     "取\n",
     "$$\n",
     "P\\left\\{\\frac{\\overline{X}- \\mu}{\\sigma/\\sqrt{n}} \\le \\frac{\\overline{k}- \\mu_{0}}{\\sigma/\\sqrt{n}}\\right\\} = \\alpha\n",
     "$$\n",
     "则 \n",
     "$$\n",
     "\\begin{aligned}\n",
     "&\\frac{\\overline{k}- \\mu_{0}}{\\sigma/\\sqrt{n}} = -z_{\\alpha} \\\\\n",
     "& k = -z_{\\alpha}\\sigma/\\sqrt{n} + - \\mu_{0}\n",
     "\\end{aligned}\n",
     "$$\n",
     "得拒绝域\n",
     "$$\n",
     "\\begin{aligned}\n",
     "&\\overline{x} \\le k= -z_{\\alpha}\\sigma/\\sqrt{n} +  \\mu_{0} \\\\\n",
     "&\\frac{\\overline{x}- \\mu_{0}}{\\sigma/\\sqrt{n}} \\le -z_{\\alpha}\n",
     "\\end{aligned}\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 💡讨论：在右边检验中，为什么令$\\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}} = z_{\\alpha}$，而在左边检验中令$\\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}} = -z_{\\alpha}$？      \n",
     "> 因为(左边检验)$$P\\left\\{ \\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\le \\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}\\right\\} = \\int_{-\\infty}^{\\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}}f(x)dx, \\quad (f(x)为x的概率密度函数)$$要使，$$P\\left\\{ \\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\le \\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}\\right\\}=\\alpha$$则取$$\\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}} = -z_{\\alpha}$$    \n",
     ">同理(右边检验)$$P\\left\\{ \\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\ge \\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}\\right\\} = \\int_{\\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}}^{\\infty}f(x)dx, \\quad (f(x)为x的概率密度函数)$$要使，$$P\\left\\{ \\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\ge \\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}\\right\\}=\\alpha$$则取$$\\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}} = z_{\\alpha}$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 这里只讨论了犯第一类错误得情况（即H_{0}为真时拒绝H_{0}），犯第二类错误（即H_{0}不真时接受H_{0}）情况的分析过程与第一类相似，掌握一种即可，这种只限制第一类错误概率，而不考虑第二类错误概率的假设检验称为**显著性检验（显著性水平为$\\alpha$）**。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🔥例子：公司购买了$5$批牛奶，现公司怀疑牛奶掺了水，已知天然牛奶的冰点温度服从正太分布，均值为$-0.545$，标准差为$0.008$，牛奶掺水可视牛奶的冰点温度升高至近似水的冰点温度，测得公司购买的$5$批牛奶的冰点温度均值$\\overline{x}=-0.535$，问牛奶是否掺了水？取$\\alpha=0.05$."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🦊解:\n",
     "1. 作出假设\n",
     "$$\n",
     "H_{0}: \\mu \\le \\mu_{0}=-0.545; \\quad H_{1}: \\mu > \\mu_{0}=-0.545\n",
     "$$\n",
     "问题即是判断假设$H_{0}$是否为真，通过假设可知该问题是**右边检验**问题\n",
     "\n",
     "2. 找拒绝域\n",
     "当拒绝$H_{0}$时，$\\mu$大于$\\mu_{0}$，因此，拒绝域的形式为\n",
     "$$ \\overline{x} \\ge k$$\n",
     "\n",
     "3. 确定常数$k$\n",
     "$$\n",
     "\\begin{aligned}\n",
     "P\\left\\{H_{0}为真时拒绝H_{0}\\right\\} &= P\\left\\{ \\overline{x} \\ge k \\right\\} \\\\\n",
     "& = P\\{ \\frac{\\overline{X} - \\mu_{0}}{\\sigma/\\sqrt{n}} \\ge \\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}\\} \\\\\n",
     "&\\le P\\{ \\frac{\\overline{X} - \\mu}{\\sigma/\\sqrt{n}} \\ge \\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}\\}  \\quad  (\\mu \\le \\mu_{0})\\\\\n",
     "&= \\alpha\n",
     "\\end{aligned}\n",
     "$$\n",
     "4. 取$\\frac{k - \\mu_{0}}{\\sigma/\\sqrt{n}}=z_{\\alpha}$，得\n",
     "$$\n",
     "k = \\sigma/\\sqrt{n}z_{\\alpha} + \\mu_{0}\n",
     "$$\n",
     "即\n",
     "$$\n",
     "\\begin{aligned}\n",
     "&\\overline{x} \\ge \\sigma/\\sqrt{n}z_{\\alpha} + \\mu_{0} \\\\\n",
     "&\\frac{\\overline{x} - \\mu_{0}}{\\sigma/\\sqrt{n}} \\ge z_{\\alpha}\n",
     "\\end{aligned}\n",
     "$$\n",
     "时拒绝$H_{0}$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码（求解例题）"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 16,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "检验统计量-0.5350 >= -0.5391, 拒绝假设H0, 即牛奶掺了水\n"
      ]
     }
    ],
    "source": [
     "from scipy.stats import norm \n",
     "import numpy as np\n",
     "\n",
     "n = 5\n",
     "alpha = 0.05 \n",
     "mu, sigma = -0.545, 0.008\n",
     "x_mean = -0.535\n",
     "\n",
     "z_alpha = - norm.ppf(loc=0, scale=1, q=0.05)\n",
     "k = (sigma/np.sqrt(n))*z_alpha + mu \n",
     "\n",
     "if x_mean >= k:\n",
     "    print(\"检验统计量{:.4f} >= {:.4f}, 拒绝假设H0, 即牛奶掺了水\".format(x_mean, k))\n",
     "else:\n",
     "    print(\"检验统计量{:.4f} < {:.4f}, 接受假设H0, 即牛奶未掺水\".format(x_mean, k))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 1.10 假设检验之正态总体参数的假设检验"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 单个总体$N(0, 1)$均值$\\mu$的检验"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "&emsp;&emsp;(1) **$\\sigma^{2}$已知，关于$\\mu$的检验（$Z$检验）**：上面已经讨论过这种情况，这种情况下，检验统计量为$Z = \\frac{\\overline{X}-\\mu_{0}}{\\sigma/\\sqrt{n}}$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "&emsp;&emsp;(2) **$\\sigma^{2}$未知，关于$\\mu$的检验（$t$检验）**：设总体$X\\sim N(\\mu, \\sigma^{2})$，$\\mu, \\sigma^{2}$未知，求检验问题\n",
     "$$\n",
     "H_{0}: \\mu =\\mu_{0}; \\quad H_{1}:\\mu \\ne \\mu_{0}\n",
     "$$\n",
     "的拒绝域(显著性水平为$\\alpha$)"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "&emsp;&emsp;🦊：这时，令检验统计量为\n",
     "$$\n",
     "\\frac{\\overline{X}-\\mu_{0}}{S/\\sqrt{n}}  , \\quad (S为样本标准差)\n",
     "$$\n",
     "根据之前学的定理知，$H_{0}$为真时：\n",
     "$$\n",
     "\\frac{\\overline{X}-\\mu_{0}}{S/\\sqrt{n}} \\sim t(n-1)\n",
     "$$\n",
     "选定适当正数$k$\n",
     "$$\n",
     "\\begin{aligned}\n",
     "P\\left\\{ H_{0}为真时拒绝H_{0}\\right\\} &=  P\\left\\{ \\left| \\frac{\\overline{X}-\\mu_{0}}{S/\\sqrt{n}} \\right| \\ge k \\right\\}\n",
     "&= \\alpha\n",
     "\\end{aligned}\n",
     "$$\n",
     "取$k = t_{\\alpha/2}(n-1)$\n",
     "则拒绝域为\n",
     "$$\n",
     "\\left| \\frac{\\overline{X}-\\mu_{0}}{S/\\sqrt{n}} \\right | \\ge k = t_{\\alpha/2}(n-1)\n",
     "$$\n",
     "这类检验方法称为 **$t$检验法**。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🔥例子：某元件寿命$X（单位：h）$服从正态分布$N(\\mu, \\sigma^{2})，\\mu, \\sigma^{2}$未知，现测得16只元件寿命如下:\n",
     "$$\n",
     "\\begin{aligned}\n",
     "& 159 \\quad 280 \\quad 101 \\quad 212 \\quad 224 \\quad 379 \\quad 179 \\quad 264 \\\\\n",
     "& 222 \\quad 362 \\quad 168 \\quad 250 \\quad 149 \\quad 260 \\quad 485 \\quad 170\n",
     "\\end{aligned}\n",
     "$$\n",
     "问元件的平均寿命是否大于$225h$（取$\\alpha = 0.05$）?"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🦊解：\n",
     "\n",
     "1. 作出假设\n",
     "$$\n",
     "H_{0}: \\mu \\le \\mu_{0} = 225; \\quad H_{1}: \\mu > \\mu_{0} = 225\n",
     "$$\n",
     "拒绝$H_{0}$时，观察值$\\overline{x}$较大，取一适当正数$k$，拒绝域的形式为\n",
     "$$\n",
     "\\overline{x} \\ge k\n",
     "$$\n",
     "2. 确定正数$k$\n",
     "$$\n",
     "\\begin{aligned}\n",
     "P\\left\\{H_{0}为真时拒绝H_{0}\\right\\} &= P\\left\\{\\overline{X} \\ge k\\right\\} \\\\\n",
     "&= P\\left\\{\\frac{\\overline{X} - \\mu_{0}}{S/\\sqrt{n}} \\ge \\frac{k- \\mu_{0}}{S/\\sqrt{n}}\\right\\} \\\\\n",
     "&\\le P\\left\\{\\frac{\\overline{X} - \\mu}{S/\\sqrt{n}} \\ge \\frac{k- \\mu_{0}}{S/\\sqrt{n}}\\right\\}, \\quad (\\mu \\le \\mu_{0}) \\\\\n",
     "&= \\alpha\n",
     "\\end{aligned}\n",
     "$$\n",
     "令$\\frac{k- \\mu_{0}}{S/\\sqrt{n}} = t_{\\alpha}(n-1)$\n",
     "\n",
     "4. 则拒绝域为\n",
     "$$\n",
     "\\overline{x} \\ge k = t_{\\alpha}(n-1)S/\\sqrt{n} + \\mu_{0}\n",
     "$$\n",
     "即\n",
     "$$\n",
     "\\frac{\\overline{x} - \\mu_{0}}{S/\\sqrt{n}} \\ge t_{\\alpha}(n-1)\n",
     "$$\n",
     "若满足上列不等式时，拒绝$H_{0}$，接受$H_{1}$，即元件的平均寿命大于$225h$，反之，则接受$H_{0}$，拒绝$H_{1}$，即元件的平均寿命小于$225h$。\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码(求解上题)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 17,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "检验统计量 : 0.6685 < 1.7531 (t_alpha(n-1)), 接受H0, 拒绝H1, 即元件平均寿命小于 225 h\n"
      ]
     }
    ],
    "source": [
     "from scipy.stats import t\n",
     "import numpy as np\n",
     "\n",
     "# H0: mu <= 225; H1: mu > 225,  mu0 = 225, alpha=0.05\n",
     "alpha = 0.05\n",
     "n = 16\n",
     "mu0 = 225\n",
     "x = [159, 280, 101, 212, 224, 379, 179, 264, 222, 362, 168, 250, 149, 260, 485, 170]\n",
     "x_mean = np.mean(x)\n",
     "S = np.sqrt(np.sum(np.square(x - x_mean))/(n-1))\n",
     "\n",
     "check = (x_mean - mu0)/(S/np.sqrt(n))\n",
     "t_alpha = - t.ppf(df=n-1, q=alpha)\n",
     "\n",
     "if check >= t_alpha:\n",
     "    print(\"检验统计量 : {:.4f} >= {:.4f} (t_alpha(n-1)), 拒绝H0, 接受H1, 即元件平均寿命大于 225 h\".format(check, t_alpha))\n",
     "else:\n",
     "    print(\"检验统计量 : {:.4f} < {:.4f} (t_alpha(n-1)), 接受H0, 拒绝H1, 即元件平均寿命小于 225 h\".format(check, t_alpha))"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 两个正态总体均值差的检验（$t$检验）"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "设$X_{1}, X_{2}, \\cdots, X_{n1}$是来自正态总体$N(\\mu_{1}, \\sigma_{1}^{2})$的样本，$Y_{1}, Y_{2}, \\cdots, Y_{n2}$是来自正态总体$N(\\mu_{2}, \\sigma_{2}^{2})$的样本，设两样本独立，样本均值和方差分别为$\\overline{X}, \\overline{Y}, S_{1}^{2}, S_{2}^{2}$，求检验问题\n",
     "$$\n",
     "H_{0}:\\mu_{1} - \\mu_{2} = \\delta; \\quad H_{1}:\\mu_{1} - \\mu_{2} \\ne \\delta\n",
     "$$\n",
     "$\\delta$为常数，显著性水平取$\\alpha$\n",
     "\n",
     "&emsp;&emsp;**（1）$\\mu_{1}, \\mu_{2}$未知, $\\sigma_{1}^{2} = \\sigma_{2}^{2} = \\sigma^{2}$未知**，取检验统计量\n",
     "$$\n",
     "t = \\frac{\\overline{X} - \\overline{Y} - \\delta}{S_{w}\\sqrt{\\frac{1}{n1}+\\frac{1}{n2}}}, \\quad S_{w}^{2} = \\frac{(n1-1)S_{1}^{2}+(n2-1)S_{2}^{2}}{n1+n2-2} , \\quad S_{w} = \\sqrt{S_{w}^{2}}\n",
     "$$\n",
     "拒绝域为\n",
     "$$\n",
     "\\frac{\\left|\\overline{x} - \\overline{y} - \\delta \\right |}{s_{w}\\sqrt{\\frac{1}{n1}+\\frac{1}{n2}}} \\ge t_{\\alpha/2}(n1+n2-2)\n",
     "$$\n",
     "&emsp;&emsp;**（2）$\\mu_{1}, \\mu_{2}$未知, $\\sigma_{1}^{2}, \\sigma_{2}^{2}$已知**，取检验统计量\n",
     "$$\n",
     "Z = \\frac{\\overline{X} - \\overline{Y} - \\delta}{\\sqrt{\\frac{\\sigma_{1}^{2}}{n1} + \\frac{\\sigma_{2}^{2}}{n1}}}\n",
     "$$\n",
     "拒绝域为\n",
     "$$\n",
     "\\frac{\\left|\\overline{x} - \\overline{y} - \\delta\\right|}{\\sqrt{\\frac{\\sigma_{1}^{2}}{n1} + \\frac{\\sigma_{2}^{2}}{n1}}} \\ge z_{\\alpha/2}\n",
     "$$\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 正态总体方差的假设检验（单个总体的情况）"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "&emsp;&emsp;设总体$X \\sim N(\\mu, \\sigma^{2})，\\mu, \\sigma^{2}$均未知，$X_{1}, X_{2}, \\cdots, X_{n}$，是来自$X$的样本，要求检验假设\n",
     "$$\n",
     "H_{0}:\\sigma^{2}=\\sigma_{0}^{2}; \\quad H_{1}=\\sigma^{2} \\ne \\sigma_{0}^{2}\n",
     "$$\n",
     "$\\sigma_{0}^{2}$为已知常数\n",
     "\n",
     "由于$S^{2}$是$\\sigma^{2}$的无偏估计，当$H_{0}$为真时，观察值$s^{2}$与$\\sigma^{2}$应该在$1$附近摆动，而不应过分大于或小于$1$，由前面学习的定理知，当$H_{0}$为真时\n",
     "$$\n",
     "\\frac{(n-1)S^{2}}{\\sigma_{0}^{2}} \\sim \\chi^{2}(n-1)\n",
     "$$\n",
     "取检验统计量\n",
     "$$\n",
     "\\chi^{2} = \\frac{(n-1)S^{2}}{\\sigma_{0}^{2}}\n",
     "$$\n",
     "如上所说，上述问题的拒绝域具有以下的形式：\n",
     "$$\n",
     "\\frac{(n-1)S^{2}}{\\sigma_{0}^{2}} \\le k_{1} \\quad 或 \\frac{(n-1)S^{2}}{\\sigma_{0}^{2}} \\ge k_{2}\n",
     "$$\n",
     "其中$k_{1}, k_{2}$的值由下式确定\n",
     "$$\n",
     "\\begin{aligned}\n",
     "&P\\left\\{H_{0}为真时拒绝H_{0}\\right\\} \\\\\n",
     "&P\\left\\{(\\frac{(n-1)S^{2}}{\\sigma_{0}^{2}} \\le k_{1}) \\cup  (\\frac{(n-1)S^{2}}{\\sigma_{0}^{2}} \\ge k_{2}) \\right\\}\n",
     "& = \\alpha\n",
     "\\end{aligned}\n",
     "$$\n",
     "为方便计算，取\n",
     "$$\n",
     "P\\left\\{\\frac{(n-1)S^{2}}{\\sigma_{0}^{2}} \\le k_{1}\\right\\} =\\frac{\\alpha}{2}  P\\left\\{ \\frac{(n-1)S^{2}}{\\sigma_{0}^{2}} \\ge k_{2}\\right\\}=\\frac{\\alpha}{2}\n",
     "$$\n",
     "得$k_{1}=\\chi_{1-\\alpha/2}^{2}(n-1), k_{2}=\\chi_{\\alpha/2}^{2}(n-1)\\quad (这里因为\\chi^{2}分布的图像不是对称的)$ ，于是得拒绝域为\n",
     "$$\n",
     "\\frac{(n-1)S^{2}}{\\sigma_{0}^{2}} \\le \\chi_{1-\\alpha/2}^{2}(n-1) {或} \\frac{(n-1)S^{2}}{\\sigma_{0}^{2}} \\ge \\chi_{\\alpha/2}^{2}(n-1)\n",
     "$$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "📕**表1.10 正态总体均值、方差的检验法（显著性水平为$\\alpha$）**"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "<style>\n",
     "table\n",
     "{\n",
     "    margin: auto;\n",
     "}\n",
     "</style>\n",
     "\n",
     "| |原假设$H_{0}$|检验统计量|备择假设$H_{1}$|拒绝域|\n",
     "|:--:|:--:|:--:|:--:|:--:|\n",
     "|$1$|$\\begin{aligned} &\\mu \\leqslant \\mu_{0} \\\\ &\\mu \\geqslant \\mu_{0} \\\\ &\\mu=\\mu_{0}\\\\ &\\left(\\sigma^{2}\\right. 已知)\\end{aligned}$|$ Z=\\frac{\\bar{X}-\\mu_{0}}{\\sigma / \\sqrt{n}}$|$\\begin{aligned} &\\mu>\\mu_{0} \\\\ & \\mu<\\mu_{0} \\\\ & \\mu\\ne\\mu_{0}\\end{aligned}$|$\\begin{aligned} &z\\ge z_{\\alpha} \\\\ &z \\le -z_{\\alpha} \\\\ & \\|z\\| \\ge z_{\\alpha / 2}\\end{aligned}$|\n",
     "|$2$|$\\begin{aligned}&\\mu \\leqslant \\mu_{0} \\\\ &\\mu \\geqslant \\mu_{0} \\\\ &\\mu=\\mu_{0}\\\\ &\\left(\\sigma^{2}\\right. 未知)\\end{aligned}$|$\\begin{aligned} t =\\frac{\\overline{X}-\\mu_{0}}{S/\\sqrt{n}} \\end{aligned}$|$\\begin{aligned} &\\mu>\\mu_{0} \\\\ & \\mu<\\mu_{0} \\\\ & \\mu\\ne\\mu_{0}\\end{aligned}$|$\\begin{aligned}& t \\geqslant t_{\\alpha}(n-1) \\\\&t \\leqslant-t_{\\alpha}(n-1) \\\\& \\|t\\| \\geqslant t_{\\alpha / 2}(n-1) \\\\ \\end{aligned}$|\n",
     "|$3$|$\\begin{aligned} &\\mu_{1}-\\mu_{2}\\le \\delta \\\\&\\mu_{1}-\\mu_{2}\\ge \\delta \\\\&\\mu_{1}-\\mu_{2}= \\delta\\\\&(\\sigma_{1}^{2},\\sigma_{2}^{2}已知) \\end{aligned}$|$\\begin{aligned}Z=\\frac{\\overline{X}-\\overline{Y}-\\delta}{\\sqrt{\\frac{\\sigma_{1}^{2}}{n1}+\\frac{\\sigma_{1}^{2}}{n2}}} \\end{aligned}$|$\\begin{aligned}&\\mu_{1}-\\mu_{2}> \\delta \\\\&\\mu_{1}-\\mu_{2}< \\delta \\\\&\\mu_{1}-\\mu_{2}\\ne \\delta  \\end{aligned}$|$\\begin{aligned} &z\\ge z_{\\alpha} \\\\ & z\\le -z_{\\alpha}\\\\ & \\| z\\| \\ge z_{\\alpha/2}\\end{aligned}$|\n",
     "|$4$|$\\begin{aligned}&\\mu_{1}-\\mu_{2}\\le \\delta \\\\&\\mu_{1}-\\mu_{2}\\ge \\delta \\\\&\\mu_{1}-\\mu_{2}= \\delta\\\\&(\\sigma_{1}^{2}=\\sigma_{2}^{2}=\\sigma^{2}未知) \\end{aligned}$|$\\begin{aligned}&t=\\frac{\\overline{X}-\\overline{Y}-\\delta}{S_{w}\\sqrt{\\frac{1}{n1}+\\frac{1}{n2}}} \\\\ & S_{w}^{2}=\\frac{(n1-1)S_{1}^{2}+(n2-1)S_{2}^{2}}{n1+n2-2} \\end{aligned}$|$\\begin{aligned}&\\mu_{1}-\\mu_{2}> \\delta \\\\&\\mu_{1}-\\mu_{2}< \\delta \\\\&\\mu_{1}-\\mu_{2}\\ne \\delta \\end{aligned}$|$\\begin{aligned}&t\\ge t_{\\alpha}(n1+n2-2) \\\\&t \\le -t_{\\alpha}(n1+n2-2)\\\\&\\|t\\| \\ge t_{\\alpha/2}(n1+n2-2) \\end{aligned}$|\n",
     "|$5$|$\\begin{aligned}&\\sigma_{1}^{2}\\le \\sigma_{2}^{2} \\\\&\\sigma_{1}^{2}\\ge \\sigma_{2}^{2}\\\\ &\\sigma_{1}^{2}= \\sigma_{2}^{2}\\\\ &(\\mu 未知) \\end{aligned}$|$\\begin{aligned}\\chi^{2}=\\frac{(n-1)S^{2}}{\\sigma_{0}^{2}} \\end{aligned}$|$\\begin{aligned}&\\sigma_{1}^{2}>\\sigma_{2}^{2} \\\\&\\sigma_{1}^{2}< \\sigma_{2}^{2}\\\\ &\\sigma_{1}^{2}\\ne \\sigma_{2}^{2} \\end{aligned}$|$\\begin{aligned}&\\chi^{2}\\ge \\chi_{\\alpha}^{2}(n-1) \\\\&\\chi^{2}\\le \\chi_{1-\\alpha}^{2}(n-1) \\\\&\\chi^{2}\\ge \\chi_{\\alpha/2}^{2}(n-1)或\\\\&\\chi^{2}\\le \\chi_{1-\\alpha/2}^{2}(n-1) \\end{aligned}$|\n",
     "|$6$|$\\begin{aligned}&\\sigma_{1}^{2}\\le \\sigma_{2}^{2} \\\\&\\sigma_{1}^{2}\\ge \\sigma_{2}^{2}\\\\ &\\sigma_{1}^{2}= \\sigma_{2}^{2}\\\\ &(\\mu_{1},\\mu_{2}未知)\\end{aligned}$|$\\begin{aligned}F=\\frac{S_{1}^{2}}{S_{2}^{2}} \\end{aligned}$|$\\begin{aligned}&\\sigma_{1}^{2}>\\sigma_{2}^{2} \\\\&\\sigma_{1}^{2}< \\sigma_{2}^{2}\\\\ &\\sigma_{1}^{2}\\ne \\sigma_{2}^{2} \\end{aligned}$|$\\begin{aligned}&F\\ge F_{\\alpha}(n1-1, n2-1) \\\\&F\\le F_{1-\\alpha}(n1-1, n2-1) \\\\ & F\\ge F_{\\alpha/2}(n1-1, n2-1)或\\\\&F\\le F_{1-\\alpha/2}(n1-1, n2-1)\\end{aligned}$|\n",
     "|$7$|$\\begin{aligned}&\\mu_{D}\\le 0\\\\&\\mu_{D}\\ge 0 \\\\&\\mu_{D}= 0\\\\&(成对数据)\\end{aligned}$|$\\begin{aligned}t=\\frac{\\overline{D}-0}{S_{D}/\\sqrt{n}} \\end{aligned}$|$\\begin{aligned}&\\mu_{D}> 0\\\\&\\mu_{D}< 0 \\\\&\\mu_{D}\\ne 0 \\end{aligned}$|$\\begin{aligned}&t\\ge t_{\\alpha}(n-1) \\\\&t\\le -t_{\\alpha}(n-1)\\\\&\\|t\\|\\ge t_{\\alpha/2}(n-1) \\end{aligned}$|"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> 置信区间与假设检验之间的关系, 假设置信区间$(\\underline{\\theta}, \\overline{\\theta})$，显著性水平为$\\alpha$\n",
     "> - 1. 检验问题$$H_{0}: \\theta=\\theta_{0};\\quad H_{0}: \\theta\\ne \\theta_{0}$$ 若检验统计量在区间$(\\underline{\\theta}, \\overline{\\theta})$内，则接受$H_{0}$，否则，拒绝$H_{0}$。\n",
     "> - 2. 检验问题$$H_{0}: \\theta\\ge \\theta_{0};\\quad H_{0}: \\theta < \\theta_{0}$$ 若检验统计量在区间$(-\\infty, \\overline{\\theta})$内，则接受$H_{0}$，否则，拒绝$H_{0}$。\n",
     "> - 3. 检验问题$$H_{0}: \\theta\\le \\theta_{0};\\quad H_{0}: \\theta > \\theta_{0}$$ 若检验统计量在区间$(\\underline{\\theta}, \\infty)$内，则接受$H_{0}$，否则，拒绝$H_{0}$。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "## 1.11 假设检验之似然比检验与Bootstrap方法"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* 似然比检验：\n",
     "\n",
     "&emsp;&emsp;定义（广义似然比）：设  $x_{1}, \\cdots, x_{n}$  为来自密度函数为  $p(x ; \\theta), \\theta \\in \\Theta$  的样本，考虑检验问题\n",
     " $$\n",
     " H_{0}: \\theta \\in \\Theta_{0} \\quad v s \\quad H_{1}: \\theta \\in \\Theta_{1}=\\Theta-\\Theta_{0}\n",
     " $$  \n",
     " 令\n",
     " $$\\Lambda\\left(x_{1}, \\cdots, x_{n}\\right)=\\frac{\\sup _{\\theta \\in \\Theta} p\\left(x_{1}, \\cdots, x_{n} ; \\theta\\right)}{\\sup _{\\theta \\in \\Theta_{0}} p\\left(x_{1}, \\cdots, x_{n} ; \\theta\\right)}  \\quad \\sup 表示最小上界$$\n",
     "那么称它为假设检验问题的广义似然比。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "&emsp;&emsp;由上式可以看出，广义似然比定义下的分子分母都有一个上确界（$\\sup$）的符号，仔细观察，分子就相当于在**全参数空间**下取联合概率密度的最大值，分母相当于在**原假设参数空间**下取联合概率密度的 最大值，所以这个比值就是两个极大似然估计的比值。直观来看，如果原假设是正确的，那么参数 应该会落在原假设的参数空间内，换句话说，分子的最大值对应的参数应该落在  $\\Theta_{0}$  ，所以这个 比值就不会太大。但是，反过来说，如果原假设应该被拒绝，那么参数就有很大可能落在拒绝域， 那么全参数空间的最大值就会在  $\\theta \\in \\Theta_{1}$  中取到，那么这个时候比值就会变大。所以可以看出 来，拒绝域顺理成章的应该设置为\n",
     "$$\n",
     "W=\\left\\{\\Lambda\\left(x_{1}, \\cdots, x_{n}\\right) \\geq c\\right\\}\n",
     "$$\n",
     "其中临界值  $c$  要满足  $P_{\\theta}\\left(\\Lambda\\left(x_{1}, \\cdots, x_{n}\\right) \\geq c\\right) \\leq \\alpha, \\forall \\theta \\in \\Theta_{0}$. "
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     ">💡 $2ln \\Lambda (\\left(x_{1}, \\cdots, x_{n}\\right))$服从$\\chi^{2}$分布，自由度为独立参数的个数（需要检验参数的维度）"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🔥例子:假设观察某种疾病的发生情况:  $n=100$  人中发生了  $k=10$  个事件。假定数据服从二项分布, 理论已知人群中每个人发生该事件的概率为  $\\pi_{0}=0.2$  。试对该假设做似然比假设检验（显著性水平$\\alpha=0.05$）?"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🦊解：\n",
     "1. 作出假设\n",
     "$$\n",
     "H_{0}: \\pi = \\pi_{0}=0.2; \\quad H_{1}: \\pi\\ne \\pi_{0}=0.2\n",
     "$$\n",
     "2. 写出参数空间\n",
     "$$\n",
     "\\Theta_{0}=\\{\\pi_{0}\\}, \\quad \\Theta = \\{\\pi, \\pi \\in \\textbf{R}\\}\n",
     "$$\n",
     "3. 计算全参数空间（$\\Theta$）下的极大似然估计\n",
     "$$\n",
     "\\begin{aligned}\n",
     "&f(x) = C_{n}^{k}p^{k}(1-p)^{n-k}\\\\\n",
     "&ln f(x) = lnC_{n}^{k} + lnp^{k}+ ln(1-p)^{n-k}\\\\\n",
     "&令 \\frac{d}{dp}ln f(x) = 0 \\\\\n",
     "&解得 \\\\\n",
     "&p = \\frac{k}{n}\n",
     "\\end{aligned}\n",
     "$$\n",
     "4. 在$H_{0}$假设下，$p = 0.2$，计算$2ln\\frac{\\sup_{\\theta\\in\\Theta }p(x_{1}, x_{2}, \\cdots, x_{n})}{\\sup_{\\theta\\in\\Theta_{0}} p(x_{1}, x_{2}, \\cdots, x_{n})}$，为\n",
     "$$\n",
     "check = 2ln\\frac{k/n}{0.2}\n",
     "$$\n",
     "5. 因为\n",
     "$$2ln\\frac{\\sup_{\\theta\\in\\Theta }p(x_{1}, x_{2}, \\cdots, x_{n})}{\\sup_{\\theta\\in\\Theta_{0}} p(x_{1}, x_{2}, \\cdots, x_{n})}\\sim \\chi^{2}(1)$$\n",
     "6. 因此，拒绝域为\n",
     "$$\n",
     "check \\ge \\chi_{\\alpha/2}(1) 或 check \\le \\chi_{1 - \\alpha/2}(1)\n",
     "$$\n",
     "7. 判断$check$值是否在拒绝域，若在，则拒绝$H_{0}$，否则接受$H_{0}$."
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码（求解上题）"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 18,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "似然比统计量为:-1.3862943611198906\n",
       "拒绝域为(0, 0.0009820691171752555)或(5.023886187314888, oo)\n",
       "拒绝假设H0, 即每个人发生该事件得概率不为0.2\n"
      ]
     }
    ],
    "source": [
     "import numpy as np \n",
     "from scipy.stats import chi2 \n",
     "\n",
     "p0 = 0.2\n",
     "n = 100\n",
     "k = 10\n",
     "alpha = 0.05\n",
     "check = 2 * np.log((k/n)/p0)\n",
     "left = chi2.ppf(df=1, q=alpha/2)\n",
     "right = chi2.ppf(df=1, q=(1-alpha/2))\n",
     "print(\"似然比统计量为:{}\".format(check))\n",
     "print(\"拒绝域为(0, {})或({}, oo)\".format(left, right))\n",
     "if check <= left or right >= right:\n",
     "    print(\"拒绝假设H0, 即每个人发生该事件得概率不为0.2\")"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "* Bootstrap方法：在上述方法中，如果分布的自由度难以确定，这个方法将难以进行下去。换句话说，当碰到某个统计量的分布难以确定或者未知的时候如何做假设检验呢？Bootstrap方法就是在这一背景下产生的。设总体得分布$F$未知，但已经有一个容量为$n$得来自分布$F$的数据样本，自这一样本按放回抽样的方法抽取一个容量为$n$的样本，这种样本称为**bootstrap**样本或自助样本，相继地、独立地自原始样本中抽取很多个bootstrap样本，利用这些样本对总体$F$进行统计推断，这种方法称为**非参数bootstrap方法**。"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "> bootstrap置信区间：设$X=X_{1}, X_{2}, \\cdots, X_{n}$是来自总体$F$容量为$n$的样本，$x=x_{1}, x_{2}, \\cdots, x_{n}$是一个已知的样本值，$F$中含有未知参数$\\theta$，$\\hat{\\theta}=\\hat{\\theta}(X_{1}, X_{2}, \\cdots, X_{n})$是$\\theta$的估计量，$\\theta$的置信水平为$1-\\alpha$（显著性水平为$\\alpha$）的置信区间为:相继地、独立地从样本$x=x_{1}, x_{2}, \\cdots, x_{n}$中抽出B个容量为n的bootstrap样本，对于每个样本求出的$\\theta$的bootstrap估计：$\\hat{\\theta_{1}}, \\hat{\\theta_{2}}, \\cdots, \\hat{\\theta_{n}}$,将他们从小到大排序：$$\\hat{\\theta_{(1)}}<\\hat{\\theta_{(2)}}< \\cdots< \\hat{\\theta_{(n)}}$$ 置信区间取$$(\\hat{\\theta}(k_{1}), \\hat{\\theta}(k_{2}))$$其中，$k_{1}=[B \\frac{\\alpha}{2}], k_{2}=[B (1-\\frac{\\alpha}{2})], \\quad ([ \\cdot]表示取整)$"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🔥例子：某工厂生产以发光产品，发光产品的发光时长服从正态分布  $N\\left(\\mu, \\sigma^{2}\\right)$  ，产品的发光时长设定均值为  $250 \\mathrm{~h}$  。现在从一批产品中抽取 $10$ 个产品，测得发光时长为（单位 为: $ h  $) :\n",
     "\n",
     "$$248.8, \\quad 249.2, \\quad 250.7, \\quad 251.2, \\quad 248.0, \\quad 253.0, \\quad 248.9, \\quad 250.2, \\quad 251.2, \\quad 249.2$$\n",
     "\n",
     "问该厂的发光产品是否符合要求（显著性水平$\\alpha = 0.05$）?"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "🦊解：该问题为左边检验，单侧置信区间的形式应为$(a, +oo)$\n",
     "\n",
     "1. 作出假设\n",
     "$$\n",
     "H_{0}:\\mu \\ge \\mu_{0}=250; \\quad H_{1}:\\mu < \\mu_{0}=250\n",
     "$$\n",
     "2. 确定检验统计量$\\overline{x}$\n",
     "3. 进行$B$次bootstrap采样并计算参数$\\mu_{i}, (i=1, 2, \\cdots, B)$后从小到大排序$\\mu_{(1)}<\\mu_{(2)}<\\cdots<\\mu_{(B)}$\n",
     "4. 取$\\alpha/2, 1-\\alpha/2$分位点，得到置信区间$(\\hat{\\theta}(k_{1}), \\hat{\\theta}(k_{2}))（这是双边检验的置信区间，这里须修改为单边）$, $k_{1}=[B \\frac{\\alpha}{2}], k_{2}=[B (1-\\frac{\\alpha}{2})], \\quad ([ \\cdot]表示取整)$\n",
     "5. 判断检验统计量是否在置信区间内，若在接受$h_{0}$，否则，拒绝$H_{0}$.\n"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
     "python代码(计算上题)"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 19,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "检验统计量为:250.03999999999996\n",
       "拒绝域为:(-oo, 249.32000000000002]\n",
       "接受H0, 该厂的发光产品符合要求\n"
      ]
     }
    ],
    "source": [
     "import numpy as np\n",
     "\n",
     "# 例题为左边检验，单侧置信区间为（k1, oo）,拒绝域为(-oo, k1]\n",
     "\n",
     "mu0 = 250\n",
     "alpha = 0.05\n",
     "B = 1000\n",
     "x = [248.8, 249.2, 250.7, 251.2, 248.0, 253.0, 248.9, 250.2, 251.2, 249.2]\n",
     "x_mean= np.mean(x)\n",
     "params = []\n",
     "for i in range(B):\n",
     "    x_resample = np.random.choice(x, len(x), replace=True)\n",
     "    params.append(np.mean(x_resample))\n",
     "\n",
     "params = np.sort(params)\n",
     "\n",
     "k1 = int(B*alpha)\n",
     "left = params[k1-1]\n",
     "# right = np.percentile(params, (1-alpha)*100-1)\n",
     "print(\"检验统计量为:{}\".format(x_mean))\n",
     "print(\"拒绝域为:(-oo, {}]\".format(left))\n",
     "if x_mean > left:\n",
     "    print(\"接受H0, 该厂的发光产品符合要求\")\n",
     "else:\n",
     "    print(\"拒绝H0, 该厂的发光产品不符合要求\")"
    ]
   }
  ],
  "metadata": {
   "kernelspec": {
    "display_name": "Python 3.10.5 ('.venv': 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.10.5"
   },
   "orig_nbformat": 4,
   "vscode": {
    "interpreter": {
     "hash": "a0798e59729acf8f16dd74a5eaff0380fbaae7e20dddaf23e3973bf13b41dad4"
    }
   }
  },
  "nbformat": 4,
  "nbformat_minor": 2
 }