{ "cells": [ { "cell_type": "markdown", "metadata": { "collapsed": true }, "source": [ "# データを統計量で記述する" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 平均を求める" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "....\n", "----------------------------------------------------------------------\n", "Ran 4 tests in 0.003s\n", "\n", "OK\n" ] } ], "source": [ "import unittest\n", "\n", "'''\n", "平均を計算\n", "'''\n", "def calculate_mean(numbers): \n", " s = sum(numbers)\n", " N = len(numbers)\n", " mean = s / N\n", "\n", " return mean\n", "\n", "\n", "class TestCalculateMean(unittest.TestCase):\n", " \n", " def test_01(self):\n", " donations = [100, 60, 70, 900, 100, 200, 500, 500, 503, 600, 1000, 1200]\n", " mean = calculate_mean(donations)\n", " N = len(donations)\n", " self.assertEqual(mean, 477.75)\n", " self.assertEqual(N, 12)\n", "\n", "\n", "if __name__ == '__main__':\n", " unittest.main(argv=['first-arg-is-ignored'], exit=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 中央値を求める" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ ".......\n", "----------------------------------------------------------------------\n", "Ran 7 tests in 0.006s\n", "\n", "OK\n" ] } ], "source": [ "import unittest\n", "\n", "'''\b\n", "中央値を計算\n", "'''\n", "def calculate_median(numbers):\n", " N = len(numbers)\n", " numbers.sort()\n", "\n", " if N % 2 == 0:\n", " m1 = N / 2\n", " m2 = (N / 2) + 1\n", " m1 = int(m1) - 1\n", " m2 = int(m2) - 1\n", " median = (numbers[m1] + numbers[m2]) / 2\n", " else:\n", " m = (N + 1) / 2\n", " m = int(m) - 1\n", " median = numbers[m]\n", "\n", " return median\n", "\n", "\n", "class TestListCalculateMedian(unittest.TestCase):\n", " def test_01(self):\n", " donations = [100, 60, 70, 900, 100, 200, 500, 500, 503, 600, 1000, 1200]\n", " median = calculate_median(donations)\n", " N = len(donations)\n", " self.assertEqual(median, 500)\n", " \n", " def test_02(self):\n", " donations = [60, 70, 100, 900]\n", " median = calculate_median(donations)\n", " N = len(donations)\n", " self.assertEqual(median, 85)\n", " \n", " def test_03(self):\n", " donations = [60, 70, 100]\n", " median = calculate_median(donations)\n", " N = len(donations)\n", " self.assertEqual(median, 70)\n", "\n", "\n", "if __name__ == '__main__':\n", " unittest.main(argv=['first-arg-is-ignored'], exit=False)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 最頻値を求め度数分布表を作る\n", "### 一番多い要素を見つける" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[(4, 2), (2, 1), (1, 1), (3, 1)]\n", "[(4, 2)]\n", "[(4, 2), (2, 1)]\n", "[(4, 2)]\n", "4\n" ] } ], "source": [ "from collections import Counter\n", "\n", "simplelist = [4, 2, 1, 3, 4]\n", "c = Counter(simplelist)\n", "print(c.most_common())\n", "print(c.most_common(1))\n", "print(c.most_common(2))\n", "\n", "mode = c.most_common(1)\n", "print(mode)\n", "print(mode[0][0])\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 最頻値を探す" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "........\n", "----------------------------------------------------------------------\n", "Ran 8 tests in 0.008s\n", "\n", "OK\n" ] } ], "source": [ "import unittest\n", "\n", "'''\n", "最頻値を計算\n", "'''\n", "def calculate_mode(numbers):\n", " c = Counter(numbers)\n", " mode = c.most_common(1)\n", " return mode[0][0]\n", "\n", "\n", "class TestListCalculateMode(unittest.TestCase):\n", " def test_01(self):\n", " scores = [7, 8, 9, 2, 10, 9, 9, 9, 9, 4, 5, 6, 15, 6, 7, 8, 6, 1, 10]\n", " mode = calculate_mode(scores)\n", " self.assertEqual(mode, 9)\n", "\n", "\n", "if __name__ == '__main__':\n", " unittest.main(argv=['first-arg-is-ignored'], exit=False)\n" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ ".........\n", "----------------------------------------------------------------------\n", "Ran 9 tests in 0.005s\n", "\n", "OK\n" ] } ], "source": [ "import unittest\n", "\n", "'''\n", "数のリストに複数の最頻値があるときに最頻値を計算\n", "'''\n", "def calculate_modes(numbers):\n", " c = Counter(numbers)\n", " numbers_freq = c.most_common()\n", " max_count = numbers_freq[0][1]\n", "\n", " modes = []\n", " for num in numbers_freq:\n", " if num[1] == max_count:\n", " modes.append(num[0])\n", " return modes\n", "\n", "\n", "class TestListCalculateModes(unittest.TestCase):\n", " def test_01(self):\n", " scores = [5, 5, 5, 4, 4, 4, 9, 1, 3]\n", " modes = calculate_modes(scores)\n", " self.assertEqual(modes, [5, 4])\n", "\n", "\n", "if __name__ == '__main__':\n", " unittest.main(argv=['first-arg-is-ignored'], exit=False)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 度数分布を作る\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "| 点数 | 頻度 |\n", "| - | - |\n", "| 1 | 2 |\n", "|2|1|\n", "|4|1|\n", "|5|2|\n", "|6|3|\n", "|7|2|\n", "|8|2|\n", "|9|5|\n", "|10|2|\n" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number\tFrequency\n", "9\t5\n", "6\t3\n", "7\t2\n", "8\t2\n", "10\t2\n", "5\t2\n", "1\t2\n", "2\t1\n", "4\t1\n" ] } ], "source": [ "\"\"\"\n", "数のリストの度数分布表\n", "\"\"\"\n", "def frequency_table(numbers):\n", " table = Counter(numbers)\n", " print('Number\\tFrequency')\n", " \n", " for number in table.most_common():\n", " print('{0}\\t{1}'.format(number[0], number[1]))\n", "\n", "\n", "if __name__ == '__main__':\n", " scores = [7, 8, 9, 2, 10, 9, 9, 9, 9, 4, 5, 6, 1, 5, 6, 7, 8, 6, 1, 10]\n", " frequency_table(scores)\n" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number\tFrequency\n", "1\t2\n", "2\t1\n", "4\t1\n", "5\t2\n", "6\t3\n", "7\t2\n", "8\t2\n", "9\t5\n", "10\t2\n" ] } ], "source": [ "\"\"\"\n", "数のリストの度数分布表\n", "数の\b順に表示するよう修正\n", "\"\"\"\n", "def frequency_sorted_table(numbers):\n", " table = Counter(numbers)\n", " numbers_freq = table.most_common()\n", " numbers_freq.sort()\n", " \n", " print('Number\\tFrequency')\n", " for number in numbers_freq:\n", " print('{0}\\t{1}'.format(number[0], number[1]))\n", " \n", "\n", "if __name__ == '__main__':\n", " scores = [7, 8, 9, 2, 10, 9, 9, 9, 9, 4, 5, 6, 1, 5, 6, 7, 8, 6, 1, 10]\n", " frequency_sorted_table(scores)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 散らばりを測る\n", "### 数集合の範囲を求める" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "..........\n", "----------------------------------------------------------------------\n", "Ran 10 tests in 0.007s\n", "\n", "OK\n" ] } ], "source": [ "import unittest\n", "\n", "'''\n", "範囲を決める\n", "'''\n", "def find_range(numbers):\n", " lowest = min(numbers)\n", " highest = max(numbers)\n", " f = highest - lowest\n", "\n", " return lowest, highest, f\n", "\n", "\n", "class TestFindRange(unittest.TestCase):\n", " def test_01(self):\n", " donations = [100, 60, 70, 900, 100, 200, 500, 500, 503, 600, 1000, 1200]\n", " lowest, highest, r = find_range(donations)\n", " self.assertEqual(lowest, 60)\n", " self.assertEqual(highest, 1200)\n", " self.assertEqual(r, 1140)\n", "\n", "\n", "if __name__ == '__main__':\n", " unittest.main(argv=['first-arg-is-ignored'], exit=False)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### 分散と標準偏差を求める" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$\\frac{\\sum(x_i - x_{avg})^2}{n}$" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "..........\n", "----------------------------------------------------------------------\n", "Ran 10 tests in 0.007s\n", "\n", "OK\n" ] } ], "source": [ "import unittest\n", "\n", "'''\n", "数のリストの分散と標準偏差を求める\n", "'''\n", "def calculate_variance(numbers):\n", " s = sum(numbers)\n", " N = len(numbers)\n", " mean = s / N\n", "\n", " diff = []\n", " for num in numbers:\n", " diff.append(num - mean)\n", "\n", " squared_diff = []\n", " for d in diff:\n", " squared_diff.append(d ** 2)\n", " sum_squared_diff = sum(squared_diff)\n", " variance = sum_squared_diff / len(numbers)\n", " return variance\n", "\n", "\n", "class TestCalculateVariance(unittest.TestCase):\n", " def test_01(self):\n", " donations = [100, 60, 70, 900, 100, 200, 500, 500, 503, 600, 1000, 1200]\n", " variance = calculate_variance(donations)\n", " self.assertEqual(variance, 141047.35416666666)\n", " std = variance ** 0.5\n", " self.assertEqual(std, 375.5627166887931)\n", "\n", "\n", "if __name__ == '__main__':\n", " unittest.main(argv=['first-arg-is-ignored'], exit=False)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## ２つのデータセットの相関を計算する\n", "### 相関係数を計算する" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$\\frac{n\\sum xy - \\sum x\\sum y}{\\sqrt{n \\sum x^2 -(\\sum x)^2(n\\sum y^2 - (\\sum y)^2)}}$" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "$\\sum xy$　2つの数集合$x$と$y$の個別要素の積和 \n", "\n", "$\\sum x$　 集合$x$の数の和 \n", "\n", "$\\sum y$　 集合$y$の数の和 \n", "\n", "$(\\sum x)^2$　集合$x$の数の和の2乗 \n", "\n", "$(\\sum y)^2$　集合$y$の数の和の2乗 \n", "\n", "$\\sum x^2$　 集合$x$の数の和の2乗 \n", "\n", "$\\sum y^2$　 集合$y$の数の和の2乗" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "..........\n", "----------------------------------------------------------------------\n", "Ran 10 tests in 0.006s\n", "\n", "OK\n" ] } ], "source": [ "import unittest\n", "\n", "'''\n", "相関係数を計算するプログラム\n", "'''\n", "def find_corr_x_y(x, y):\n", " n = len(x)\n", " # 積の和を求める\n", " prod = []\n", " for xi, yi in zip(x, y):\n", " prod.append(xi * yi)\n", " sum_prod_x_y = sum(prod)\n", " sum_x = sum(x)\n", " sum_y = sum(y)\n", " squared_sum_x = sum_x ** 2\n", " squared_sum_y = sum_y ** 2\n", " x_square = []\n", " for xi in x:\n", " x_square.append(xi ** 2)\n", " # 和を求める\n", " x_square_sum = sum(x_square)\n", " y_square = []\n", " for yi in y:\n", " y_square.append(yi ** 2)\n", " # 和を求める \n", " y_square_sum = sum(y_square)\n", " # 式を使って相関を計算\n", " numerator = n * sum_prod_x_y - sum_x * sum_y\n", " denominatior_term1 = n * x_square_sum - squared_sum_x\n", " denominatior_term2 = n * y_square_sum - squared_sum_y\n", " denominator = (denominatior_term1*denominatior_term2)**0.5\n", " correlation = numerator/denominator\n", " \n", " return correlation\n", "\n", "\n", "class TestFindCorr(unittest.TestCase):\n", " def test_01(self):\n", " x = [1, 2, 3]\n", " y = [1, 2, 3]\n", " corr = find_corr_x_y(x, y)\n", " self.assertEqual(corr, 1)\n", "\n", " x = [1, 2, 3]\n", " y = [-1, -2, -3]\n", " corr = find_corr_x_y(x, y)\n", " self.assertEqual(corr, -1)\n", "\n", " x = [1, 2, 3]\n", " y = [1, -2, 3]\n", " corr = find_corr_x_y(x, y)\n", " self.assertEqual(corr, 0.39735970711951313)\n", "\n", "\n", "if __name__ == '__main__':\n", " unittest.main(argv=['first-arg-is-ignored'], exit=False)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## 散布図" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: seaborn in /Users/k2works/.pyenv/versions/3.7.0/lib/python3.7/site-packages (0.9.0)\r\n", "Requirement already satisfied: pandas>=0.15.2 in /Users/k2works/.pyenv/versions/3.7.0/lib/python3.7/site-packages (from seaborn) (0.23.4)\r\n", "Requirement already satisfied: scipy>=0.14.0 in /Users/k2works/.pyenv/versions/3.7.0/lib/python3.7/site-packages (from seaborn) (1.1.0)\r\n", "Requirement already satisfied: numpy>=1.9.3 in /Users/k2works/.pyenv/versions/3.7.0/lib/python3.7/site-packages (from seaborn) (1.15.1)\r\n", "Requirement already satisfied: matplotlib>=1.4.3 in /Users/k2works/.pyenv/versions/3.7.0/lib/python3.7/site-packages (from seaborn) (3.0.0)\r\n", "Requirement already satisfied: pytz>=2011k in /Users/k2works/.local/lib/python3.7/site-packages (from pandas>=0.15.2->seaborn) (2018.5)\r\n", "Requirement already satisfied: python-dateutil>=2.5.0 in /Users/k2works/.local/lib/python3.7/site-packages (from pandas>=0.15.2->seaborn) (2.7.3)\r\n", "Requirement already satisfied: cycler>=0.10 in /Users/k2works/.pyenv/versions/3.7.0/lib/python3.7/site-packages (from matplotlib>=1.4.3->seaborn) (0.10.0)\r\n", "Requirement already satisfied: kiwisolver>=1.0.1 in /Users/k2works/.pyenv/versions/3.7.0/lib/python3.7/site-packages (from matplotlib>=1.4.3->seaborn) (1.0.1)\r\n", "Requirement already satisfied: pyparsing!=2.0.4,!=2.1.2,!=2.1.6,>=2.0.1 in /Users/k2works/.pyenv/versions/3.7.0/lib/python3.7/site-packages (from matplotlib>=1.4.3->seaborn) (2.2.1)\r\n", "Requirement already satisfied: six>=1.5 in /Users/k2works/.local/lib/python3.7/site-packages (from python-dateutil>=2.5.0->pandas>=0.15.2->seaborn) (1.11.0)\r\n", "Requirement already satisfied: setuptools in /Users/k2works/.pyenv/versions/3.7.0/lib/python3.7/site-packages (from kiwisolver>=1.0.1->matplotlib>=1.4.3->seaborn) (39.0.1)\r\n" ] } ], "source": [ "import sys\n", "!{sys.executable} -m pip install seaborn" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import seaborn as sns\n", "import matplotlib.pyplot as plt\n", "\n", "x = [1, 2, 3, 4]\n", "y = [2, 4, 6, 8]\n", "\n", "plt.scatter(x, y)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[アンスコムの4つ組](http://blog.livedoor.jp/oyajieng_memo/archives/1677707.html)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Requirement already satisfied: numpy in /Users/k2works/.pyenv/versions/3.7.0/lib/python3.7/site-packages (1.15.1)\r\n", "Requirement already satisfied: pandas in /Users/k2works/.pyenv/versions/3.7.0/lib/python3.7/site-packages (0.23.4)\r\n", "Requirement already satisfied: pytz>=2011k in /Users/k2works/.local/lib/python3.7/site-packages (from pandas) (2018.5)\r\n", "Requirement already satisfied: python-dateutil>=2.5.0 in /Users/k2works/.local/lib/python3.7/site-packages (from pandas) (2.7.3)\r\n", "Requirement already satisfied: six>=1.5 in /Users/k2works/.local/lib/python3.7/site-packages (from python-dateutil>=2.5.0->pandas) (1.11.0)\r\n" ] } ], "source": [ "import sys\n", "!{sys.executable} -m pip install numpy pandas" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAALICAYAAABiqwZ2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvqOYd8AAAIABJREFUeJzs3XGMXdd9H/jvj+RMOLQokYKH2pYj21EQWaicNE3YdaJAEzWOUhlxZadNd500W7MiajULONqgapo4NdOlC28QC2iMFGjlWioDNHCaOvFWCCDbggvuqHGijezYiRmzcleNrKFjcQSRMh0OyyF59o83du7QojRDzsx9b+bzAYg777w79/44nDn8znnnnVOttQAAAANb+i4AAACGiYAMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIbQlX986q6/xXOeVtV/ZVVvu/rquonVulah6vqx1bjWgArtdH60ao6UlX7VuO6bD4CMpvJ25Ksasee5HVJVqVjBxgB+lE2BQGZkVVVv1BVT1XVf0ny+k77P6yqP6iqz1XVb1XVjqq6LcndSd5fVZ+tqm97qfMWP//vVtXnF9tnFtu2VtX7F8//o6q6d/F2v5Tk9sVr/sw6fwkArop+FF7atr4LgCtRVd+T5O1JviuD7+PPJPn04tO/3Vr7t4vn/YskB1prv1pVjyT5ndbaRxafO3XpeUl+NcnBJH+ztXa8qnYtXvNAkhdba3+9qr4lye9W1SeS/FyS+1trb3mJGncmefwyf4WfaK39yVV+GQCumH4ULk9AZlTdnuSjrbUzSbLYaX/dGxY76l1Jrkny8ctc43Ln/W6Sw1X1m0l+e7Hth5N8Z2eO8HVJvj3JucsV2Fo7ncF/PADDSD8KlyEgsxEdTvK21trnqmp/kjtWcl5r7R9V1RuT/EiSTy+OslSSd7XWlvwnUVWXu7aRD2CUHY5+lE3MHGRG1UySt1XVxGIH+rc6z+1M8mdVNZbk73XaTy8+97LnVdW3tdaeaK0dTDKX5MYMRkV+avHcVNXNVfWql7jmN7TWTrfWvusyf3TqQN/0o3AZRpAZSa21z1TVf0jyuSQnkvxB5+n3JHkig075ifxFx/sbSf5tVf10kh97mfPeX1XfnsFoxycX7/FHGbzT+jNVVYuf87bF9gtV9bkkh1tr/3JN/sIAq0w/CpdXrbW+awAAgKFhigUAAHQIyAAA0CEgAwBAh4AMAAAdI7GKxV133dU+9rGP9V0GQJ/qai+gLwVYXl86EiPIzz//fN8lAIw8fSnA8oxEQAYAgPUiIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANCxZgG5qh6uqhNV9flO2/ur6lhV/VFVfbSqdq3V/QEA4Eqs5Qjy4SR3XdL2WJI3tNa+M8lTSX5+De8PAAArtmYBubU2k+SFS9o+0Vo7v/jw95NMrdX9AQDgSvQ5B/meJI9e7smqemdVPVlVT87Nza1jWQAbh74UYOV6CchV9QtJzif59cud01r7YGttX2tt3+Tk5PoVB7CB6EsBVm7bet+wqvYneUuSN7XW2nrfHwAAXs66BuSquivJzyb5gdbamfW8NwAALMdaLvP24SS/l+T1VTVbVQeS/KskO5M8VlWfrap/s1b3BwCAK7FmI8ittR9/ieaH1up+AACwGuykBwAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHdv6LgBG3ZFjJ/LgzNN59uSZ3Lh7R+6dvil33LKn77IAgCtkBBmuwpFjJ3LwkaM5cfpsdk2M5cTpszn4yNEcOXai79IAgCskIMNVeHDm6YxtrewY35aqwXFsa+XBmaf7Lg0AuEICMlyFZ0+eycTY1iVtE2NbM3vyTE8VAQBXS0CGq3Dj7h2ZX7iwpG1+4UKmdu/oqSIA4GoJyHAV7p2+KQsXWs6cO5/WBseFCy33Tt/Ud2kAwBUSkOEq3HHLnhy6+9bs2bk9L84vZM/O7Tl0961WsQCAEWaZN7hKd9yyRyAGgA3ECDIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdaxaQq+rhqjpRVZ/vtF1fVY9V1RcXj7vX6v4AAHAl1nIE+XCSuy5p+7kkn2ytfXuSTy4+BgCAobFtrS7cWpupqtdd0vzWJHcsfvxrSY4k+adrVQNsdkeOnciDM0/n2ZNncuPuHbl3+qbcccuevssCgKG23nOQb2it/dnix19JcsPlTqyqd1bVk1X15Nzc3PpUBxvIkWMncvCRozlx+mx2TYzlxOmzOfjI0Rw5dqLv0lhH+lKAlevtTXqttZakvczzH2yt7Wut7ZucnFzHymBjeHDm6YxtrewY35aqwXFsa+XBmaf7Lo11pC8FWLn1DsjPVdVfSpLFo6EsWCPPnjyTibGtS9omxrZm9uSZnioCgNGw3gH5kSTvWPz4HUn+0zrfHzaNG3fvyPzChSVt8wsXMrV7R08VAcBoWMtl3j6c5PeSvL6qZqvqQJJfSnJnVX0xyQ8tPgbWwL3TN2XhQsuZc+fT2uC4cKHl3umb+i4NAIbaWq5i8eOXeepNa3VP4C/cccueHMpgLvLsyTOZsooFACzLmgVkoH933LJHIAaAFbLVNAAAdAjIAADQISADAECHgAwAAB0CMgAAdAjIAADQISADAECHgAwAAB0CMgAAdAjIAADQISADAECHgAwAAB3b+i4AABhhTz2WfOoDyalnkl2vTW67L7n5zr6rgqtiBBkAuDJPPZY8en9y+rlk++7B8dH7B+0wwgRkAODKfOoDyZbxZHxHUjU4bhkftMMIM8UCADab1ZoWceqZwchx19hEcupLq1Mn9MQIMgBsJqs5LWLXa5OF+aVtC/PJrtdceW2H35L8yncMjqZq0BMBGQA2k9WcFnHbfcnFc8m5M0lrg+PFc4P2lTKfmSEiIAPAZnLqmcE0iK4rnRZx853Jmx9Idt6QnD01OL75gSubrmE+M0PEHGQA2Ex2vXYwOju+4y/armZaxM13rs6ybuYzM0SMIAPAZrKa0yJW02rPZ4arICADwGaymtMiVtOwBnc2JVMsAGCzWa1pEavp5juTPLC4/NyXBiPHduWjJwIyADAchjG4symZYgEAAB1GkFlTR46dyIMzT+fZk2dy4+4duXf6ptxxy56+ywIAuCwjyKyZI8dO5OAjR3Pi9NnsmhjLidNnc/CRozly7ETfpQGMHrvMwboRkFkzD848nbGtlR3j21I1OI5trTw483TfpQGMFrvMrZxfKLgKAjJr5tmTZzIxtnVJ28TY1syePNNTRQAjyi5zK+MXCq6SgMyauXH3jswvXFjSNr9wIVO7d1zmMwB4Sau5PfRm4BcKrpKAzJq5d/qmLFxoOXPufFobHBcutNw7fVPfpQGMFrvMrYxfKLhKAjJr5o5b9uTQ3bdmz87teXF+IXt2bs+hu2+1igXAStllbmX8QsFVsswba+qOW/YIxABXyy5zK3PbfYM5x+cyGDlemPcLBSsiIAPAKLDL3PL5hYKrJCADABuPXyi4CuYgAwBAh4AMAAAdAjIAAHQIyAAA0OFNemxKR46dyIMzT+fZk2dy4+4duXf6JsvRAQBJjCCzCR05diIHHzmaE6fPZtfEWE6cPpuDjxzNkWMn+i4NABgCAjKbzoMzT2dsa2XH+LZUDY5jWysPzjzdd2kAwBAQkNl0nj15JhNjW5e0TYxtzezJMz1VBAAMEwGZTefG3Tsyv3BhSdv8woVM7d7RU0UAwDARkNl07p2+KQsXWs6cO5/WBseFCy33Tt/Ud2nARvLUY8nhtyS/8h2D41OP9V0RsEwCMpvOHbfsyaG7b82endvz4vxC9uzcnkN332oVC2D1PPVY8uj9yennku27B8dH7xeSYURY5o1N6Y5b9gjEwNr51AeSLePJ+OLUrfEdybnF9pvv7LU0rsBTjw3+7U49k+x6bXLbff4dNzgBmZFh7WJgZJx6ZjBy3DU2kZz6Uj/1cOW+/mrAlvGlrwbkASF5A+tlikVV/UxVHa2qz1fVh6tqex91MDqsXQyMlF2vTRbml7YtzCe7XtNPPVy57qsBVYPjlvFBOxvWugfkqtqb5KeT7GutvSHJ1iRvX+86GC3WLgZGym33JRfPJefOJK0NjhfPDdoZLaeeGYz+d3k1YMPr601625JMVNW2JDuSfLmnOhgR1i4GRsrNdyZvfiDZeUNy9tTg+GYvyY8krwZsSus+B7m1dryqHkjypSTzST7RWvvEetfBaLlx946cOH02O8b/4lvW2sXAULv5ToF4I7jtvsGc43MZjBwvzHs1YBN4xRHkqnpXVe1+pfOWa/Fab03yrUn+cpJXVdVPvsR576yqJ6vqybm5udW6PSPK2sVwZfSlcJW8GrApVWvt5U+o+hcZzBH+TJKHk3y8vdInvfz1/m6Su1prBxYf//0k39ta+98v9zn79u1rTz755JXekg3i66tYzJ48kymrWLD51NVeQF8KsLy+9BWnWLTW/llVvSfJDyf5B0n+VVX9ZpKHWmv/3xUU9qUk31tVOzKYYvGmJHpsXpG1iwGA9bCsN+ktjhh/ZfHP+SS7k3ykqn55pTdsrT2R5CMZjEj/8WINH1zpdQAAYC284ghyVd2X5O8neT7Jh5L8k9baQlVtSfLFJD+70pu21n4xyS+u9PMAAGCtLWcVi+uT/O3W2jPdxtbaxap6y9qUBQAA/VjOHOTLjvS21r6wuuUAAEC/+tooBAAAhpKADAAAHeu+kx5weV9f6/nZk2dyo7WeAaAXRpBhSBw5diIHHzmaE6fPZtfEWE6cPpuDjxzNkWMn+i4NADYVARmGxIMzT2dsa2XH+LZUDY5jWysPzjzdd2kAsKkIyDAknj15JhNjW5e0TYxtzezJMz1VBACbk4AMQ+LG3Tsyv3BhSdv8woVM7d7RU0UAsDkJyDAk7p2+KQsXWs6cO5/WBseFCy33Tt/Ud2kAsKkIyDAk7rhlTw7dfWv27NyeF+cXsmfn9hy6+1arWADAOrPMGwyRO27ZIxADQM+MIAMAQIcRZAD4uqceSz71geTUM8mu1ya33ZfcfGffVQHrTEDukV3TAIbIU48lj96fbBlPtu9OTj83eJwHhGTYZEyx6Ild0wCGzKc+MAjH4zuSqsFxy/igHdhUBOSe2DUNYMiceiYZm1jaNjaRnPpSP/UAvRGQe2LXNIAhs+u1ycL80raF+WTXa/qpB+iNgNwTu6YBDJnb7ksunkvOnUlaGxwvnhu0A5uKgNwTu6YBDJmb70ze/ECy84bk7KnB8c3eoAebkVUsenLHLXtyKIO5yLMnz2TKKhYA/bv5ToEYEJD7ZNc0AIDhIyDzTazPDABsZuYgs4T1mQGAzU5AZgnrMwMAm52AzBLWZwYANjsBmSWszwwAbHYCMktYnxkA2OwEZJa445Y9OXT3rdmzc3tenF/Inp3bc+juW61iAQBsGpZ545tYnxkA2MyMIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANCxre8CAOCqPPVY8qkPJKeeSXa9NrntvuTmO/uuChhhRpABGF1PPZY8en9y+rlk++7B8dH7B+0AV0hABmB0feoDyZbxZHxHUjU4bhkftANcoV4CclXtqqqPVNWxqvpCVX1fH3UAMOJOPZOMTSxtG5tITn2pn3qADaGvEeQPJPlYa+2WJH81yRd6qgOAUbbrtcnC/NK2hflk12v6qQfYENY9IFfVdUmmkzyUJK21c621U+tdBwAbwG33JRfPJefOJK0NjhfPDdoBrlAfI8jfmmQuyb+rqj+sqg9V1at6qAOAUXfzncmbH0h23pCcPTU4vvkBq1gAV6Vaa+t7w6p9SX4/yfe31p6oqg8k+Wpr7T2XnPfOJO9Mkte85jXf88wzz6xrnQBDpq7ok/SlAF3L6kv7GEGeTTLbWnti8fFHknz3pSe11j7YWtvXWts3OTm5rgUCbBT6UoCVW/eA3Fr7SpJnq+r1i01vSvIn610HAAC8lL520ntXkl+vqvEkTyf5Bz3VAQAAS/QSkFtrn02yr497AwDAy7GTHgAAdPQ1xWJkHTl2Ig/OPJ1nT57Jjbt35N7pm3LHLXv6LgsAgFViBHkFjhw7kYOPHM2J02eza2IsJ06fzcFHjubIsRN9lwYAwCoRkFfgwZmnM7a1smN8W6oGx7GtlQdnnu67NAAAVomAvALPnjyTibGtS9omxrZm9uSZnioCAGC1CcgrcOPuHZlfuLCkbX7hQqZ27+ipIgAAVpuAvAL3Tt+UhQstZ86dT2uD48KFlnunb+q7NAAAVomAvAJ33LInh+6+NXt2bs+L8wvZs3N7Dt19q1UsAAA2EMu8rdAdt+wRiAEANjAjyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0LGt7wJYHUeOnciDM0/n2ZNncuPuHbl3+qbcccuevssCABg5RpA3gCPHTuTgI0dz4vTZ7JoYy4nTZ3PwkaM5cuxE36UBAIwcAXkDeHDm6YxtrewY35aqwXFsa+XBmaf7Lg3gpT31WHL4LcmvfMfg+NRjfVcE8A0C8gbw7MkzmRjbuqRtYmxrZk+e6akigJfx1GPJo/cnp59Ltu8eHB+9X0gGhoaAvAHcuHtH5hcuLGmbX7iQqd07eqoI4GV86gPJlvFkfEdSNThuGR+0AwwBAXkDuHf6pixcaDlz7nxaGxwXLrTcO31T36UBfLNTzyRjE0vbxiaSU1/qpx6ASwjIG8Adt+zJobtvzZ6d2/Pi/EL27NyeQ3ffahULYDjtem2yML+0bWE+2fWafuoBuIRl3jaIO27ZIxADo+G2+wZzjs9lMHK8MJ9cPDdoBxgCRpABWF8335m8+YFk5w3J2VOD45sfGLQDDAEjyACsv5vvFIiBoWUEGQAAOgRkAADoEJABAKBDQAYAgA4BGQAAOgRkAADo2BTLvB05diIPzjydZ0+eyY27d+Te6ZtsqgEAwEva8CPIR46dyMFHjubE6bPZNTGWE6fP5uAjR3Pk2Im+SwMAYAht+ID84MzTGdta2TG+LVWD49jWyoMzT/ddGgAAQ2jDB+RnT57JxNjWJW0TY1sze/JMTxUBADDMNnxAvnH3jswvXFjSNr9wIVO7d/RUEQAAw2zDB+R7p2/KwoWWM+fOp7XBceFCy73TN/VdGgAAQ2jDB+Q7btmTQ3ffmj07t+fF+YXs2bk9h+6+1SoWAAC8pN6WeauqrUmeTHK8tfaWtbzXHbfsEYgBAFiWPkeQ70vyhR7vDwAA36SXgFxVU0l+JMmH+rg/AABcTl8jyL+S5GeTXOzp/gAA8JLWPSBX1VuSnGitffoVzntnVT1ZVU/Ozc2tU3UAG4u+FGDl+hhB/v4kd1fVnyb5jSQ/WFX//tKTWmsfbK3ta63tm5ycXO8aATYEfSnAyq17QG6t/Xxrbaq19rokb0/yn1trP7nedQAAwEvZ8OsgAwDASvS2DnKStNaOJDnSZw0AANBlBBkAADoEZAAA6BCQAQCgQ0AGAIAOARkAADoEZAAA6BCQAQCgQ0AGAIAOARkAADoEZAAA6BCQAQCgQ0AGAIAOARkAADoEZAAA6BCQAQCgQ0AGAIAOARkAADoEZAAA6NjWdwEAjIinHks+9YHk1DPJrtcmt92X3Hxn31UBrDojyAC8sqceSx69Pzn9XLJ99+D46P2DdoANRkAG4JV96gPJlvFkfEdSNThuGR+0A2wwAjIAr+zUM8nYxNK2sYnk1Jf6qQdgDQnIALyyXa9NFuaXti3MJ7te0089AGtIQAbgld12X3LxXHLuTNLa4Hjx3KAdYIMRkAF4ZTffmbz5gWTnDcnZU4Pjmx+wigWwIVnmDYDluflOgRjYFIwgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHRUa63vGl5RVc0leWYVLvXqJM+vwnVWm7pWRl0rN6y1qWv5nm+t3XU1F9CX9mZY60qGtzZ1rYy6lm9ZfelIBOTVUlVPttb29V3HpdS1MupauWGtTV2jaVi/PupauWGtTV0ro67VZ4oFAAB0CMgAANCx2QLyB/su4DLUtTLqWrlhrU1do2lYvz7qWrlhrU1dK6OuVbap5iADAMAr2WwjyAAA8LIEZAAA6BCQAQCgQ0AGAIAOARkAADoEZAAA6BCQAQCgQ0AGAIAOARkAADoEZEZWVf3zqrr/Fc55W1X9lVW+7+uq6idW6VqHq+rHFj8+UlX7Fj/+06p69WrcA+DlbKS+tKp+sar+r0ue+66q+sJq3IfNQ0Bmo3tbklXt1JO8LsmqdOoAI2JU+tIPJ/lfL2l7+2I7LJuAzEipql+oqqeq6r8keX2n/R9W1R9U1eeq6reqakdV3Zbk7iTvr6rPVtW3vdR5i5//d6vq84vtM4ttW6vq/Yvn/1FV3bt4u19KcvviNX9mnb8EAFdto/alrbWnkpysqjd2mv+XCMis0La+C4DlqqrvyWAk4Lsy+N79TJJPLz792621f7t43r9IcqC19qtV9UiS32mtfWTxuVOXnpfkV5McTPI3W2vHq2rX4jUPJHmxtfbXq+pbkvxuVX0iyc8lub+19paXqHFnkscv81f4idban1zllwHgqmyCvvTDi3+/J6rqe5O80Fr74jK+NPANAjKj5PYkH22tnUmSxQ77696w2EnvSnJNko9f5hqXO+93kxyuqt9M8tuLbT+c5Du/Pkc4yXVJvj3JucsV2Fo7ncF/OgDDaqP3pf8hyaeq6h/H9AqukIDMRnE4ydtaa5+rqv1J7ljJea21f7T4ktyPJPn04ghLJXlXa23JfxBVdblrG0EGRt3hjHhf2lp7tqr+e5IfSPJ3knzf5c6FyzEHmVEyk+RtVTWx2Hn+rc5zO5P8WVWNJfl7nfbTi8+97HlV9W2ttSdaaweTzCW5MYMRkZ9aPDdVdXNVveolrvkNrbXTrbXvuswf4RgYBpuhL/1wkn+Z5OnW2uwyzoclBGRGRmvtMxm8dPa5JI8m+YPO0+9J8kQGL+8d67T/RpJ/UlV/WFXf9jLnvb+q/riqPp/kU4v3+FCSP0nymcX2BzN41eWPklxYfBOKN+kBI2WT9KX/McmtMb2CK1Sttb5rAACAoWEEGQAAOgRkAADoEJABAKBDQAYAgI6RWAf5rrvuah/72Mf6LgOgT3W1F9CXAiyvLx2JEeTnn3++7xIARp6+FGB5RiIgAwDAehGQAQCgQ0AGAIAOARkAADoEZAAA6BCQAQCgQ0AGAIAOARkAADoEZAAA6BCQAQCgQ0AGAIAOARkAADq29V0A8Bcen308h48ezvGvHc/ea/Zm/637c/vU7X2XBQCbihFkGBKPzz6e9z3xvszNz+Xa8WszNz+X9z3xvjw++3jfpQHApiIgw5A4fPRwxraOZWLbRKoqE9smMrZ1LIePHu67NADYVARkGBLHv3Y827duX9K2fev2HP/a8Z4qAoDNSUCGIbH3mr05e+HskrazF85m7zV7e6oIADYnARmGxP5b92fhwkLmz8+ntZb58/NZuLCQ/bfu77s0ANhUBGQYErdP3Z53v/HdmZyYzFfPfTWTE5N59xvfbRULAFhnlnmDIXL71O0CMQAsOj0zkxceejgLs7MZm5rK9Qfuyc7p6TW/rxFkAACGzumZmTx36L05PzeXLdddl/Nzc3nu0HtzemZmze8tIAMAMHReeOjh1Ph4tkwMlj/dMjGRGh/PCw89vOb3FpABABg6C7Ozqe1Llz+t7duzMDu75vcWkAEAGDpjU1NpZ5cuf9rOns3Y1NSa31tABgBg6Fx/4J60c+dycX6w/OnF+fm0c+dy/YF71vzeAjIAAENn5/R0bjj4nmybnMzFF1/MtsnJ3HDwPeuyioVl3gAAGEo7p6fXJRBfyggyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANCxZgG5qh6uqhNV9flO2/ur6lhV/VFVfbSqdq3V/QEA4Eqs5Qjy4SR3XdL2WJI3tNa+M8lTSX5+De8PAAArtmYBubU2k+SFS9o+0Vo7v/jw95Os/WbaAACwAn3OQb4nyaOXe7Kq3llVT1bVk3Nzc+tYFsDGoS8FWLleAnJV/UKS80l+/XLntNY+2Frb11rbNzk5uX7FAWwg+lKAldu23jesqv1J3pLkTa21tt73BwCAl7OuAbmq7krys0l+oLV2Zj3vDQAAy7GWy7x9OMnvJXl9Vc1W1YEk/yrJziSPVdVnq+rfrNX9AQDgSqzZCHJr7cdfovmhtbofAACsBjvpAQBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAh4AMAABhOwz7AAAWR0lEQVQdAjIAAHQIyAAA0CEgAwBAh4AMAAAdAjIAAHQIyAAA0CEgAwBAx5oF5Kp6uKpOVNXnO23XV9VjVfXFxePutbo/AABcibUcQT6c5K5L2n4uySdba9+e5JOLjwEAYGisWUBurc0keeGS5rcm+bXFj38tydvW6v4AAHAl1nsO8g2ttT9b/PgrSW643IlV9c6qerKqnpybm1uf6gA2GH0pwMr19ia91lpL0l7m+Q+21va11vZNTk6uY2UAG4e+FGDl1jsgP1dVfylJFo8n1vn+AADwstY7ID+S5B2LH78jyX9a5/sDAMDLWstl3j6c5PeSvL6qZqvqQJJfSnJnVX0xyQ8tPgYAgKGxba0u3Fr78cs89aa1uicAAFwtO+kBAECHgAwAAB0CMgAAdAjIAADQISADAECHgAwAAB0CMgAAdAjIAADQISADAECHgAwAAB0CMgAAdAjIAADQISADAECHgAwAAB0CMgAAdAjIAADQISADAECHgAwAAB0CMgAAdAjIAADQISADAECHgAwAAB0CMgAAdAjIAADQISADAEDHtr4LANbO47OP5/DRwzn+tePZe83e7L91f26fur3vsmBTOD0zkxceejgLs7MZm5rK9Qfuyc7p6b7LApbBCDJsUI/PPp73PfG+zM3P5drxazM3P5f3PfG+PD77eN+lwYZ3emYmzx16b87PzWXLddfl/Nxcnjv03pyemem7NGAZBGTYoA4fPZyxrWOZ2DaRqsrEtomMbR3L4aOH+y4NNrwXHno4NT6eLRODn78tExOp8fG88NDDfZcGLIOADBvU8a8dz/at25e0bd+6Pce/drynimDzWJidTW1f+vNX27dnYXa2p4qAlRCQYYPae83enL1wdknb2Qtns/eavT1VBJvH2NRU2tmlP3/t7NmMTU31VBGwEgIybFD7b92fhQsLmT8/n9Za5s/PZ+HCQvbfur/v0mDDu/7APWnnzuXi/ODn7+L8fNq5c7n+wD19lwYsg4AMG9TtU7fn3W98dyYnJvPVc1/N5MRk3v3Gd1vFAtbBzunp3HDwPdk2OZmLL76YbZOTueHge6xiASPCMm+wgd0+dbtADD3ZOT0tEMOIMoIMAAAdAjIAAHQIyAAA0GEOMgCsAVtNw+gyggwAq8xW0zDaBGQAWGW2mobRJiADwCqz1TSMNgEZAFaZraZhtAnIALDKbDUNo01ABoBVZqtpGG2WeQOANWCraRhdRpABAKDDCDJcpcdnH8/ho4dz/GvHs/eavdl/6/7cPnV732UBAFfICDJchcdnH8/7nnhf5ubncu34tZmbn8v7nnhfHp99vO/SAIArJCDDVTh89HDGto5lYttgM4CJbRMZ2zqWw0cP910aAHCFBGS4Cse/djzbty7dDGD71u05/rXjPVUEAFytXgJyVf1MVR2tqs9X1YeravsrfxYMn73X7M3ZC0s3Azh74Wz2XrO3p4oAgKu17gG5qvYm+ekk+1prb0iyNcnb17sOWA37b92fhQsLmT8/2Axg/vx8Fi4sZP+t+/suDQC4Qn1NsdiWZKKqtiXZkeTLPdUBV+X2qdvz7je+O5MTk/nqua9mcmIy737ju61iAQAjbN2XeWutHa+qB5J8Kcl8kk+01j5x6XlV9c4k70yS17zmNetbJKzA7VO3C8QMLX1pf07PzOSFhx7Owuxsxqamcv2Be2wcAiPiFUeQq+pdVbV7tW64eK23JvnWJH85yauq6icvPa+19sHW2r7W2r7JycnVuj3ApqIv7cfpmZk8d+i9OT83ly3XXZfzc3N57tB7c3pmpu/SgGVYzhSLG5L8QVX9ZlXdVVV1lff8oST/vbU211pbSPLbSW67ymsCwNB44aGHU+Pj2TIxWAJyy8REanw8Lzz0cN+lAcvwigG5tfbPknx7koeS7E/yxap6X1V92xXe80tJvreqdiyG7Tcl+cIVXguuyOOzj+fAxw/krt+6Kwc+fsDGHsCqWpidTW1fukBTbd+ehdnZnioCVmJZb9JrrbUkX1n8cz7J7iQfqapfXukNW2tPJPlIks8k+ePFGj640uvAlbL7HbDWxqam0s4uXQKynT2bsampnioCVmI5c5Dvq6pPJ/nlJL+b5Dtaaz+V5HuS/J0ruWlr7Rdba7e01t7QWvvfWmv/40quA1fC7nfAWrv+wD1p587l4vxgCciL8/Np587l+gP39F0asAzLWcXi+iR/u7X2TLextXaxqt6yNmXB2jn+teO5dvzaJW12vwNW087p6cz/6I/m5K/9Wi7++Z9ny6teld3veIdVLGBELGcO8i9eGo47z5k7zMix+x2w1k7PzOSrH/1otr361fmW178+21796nz1ox+1igWMiL42CoHe2P0OWGtWsYDRJiCz6dj9DlhrVrGA0bbuO+nBMLD7HbCWxqamcn5uLjUx8Y02q1jA6DCCDACrzCoWMNoEZABYZTunp3PDwfdk2+RkLr74YrZNTuaGg++xigWMCFMsGBmPzz6ew0cP5/jXjmfvNXuz/9b9pkkAQ2vn9LRADCPKCDIjwe53AMB6EZAZCXa/AwDWi4DMSDj+tePZvnXpkkl2vwMA1oKAzEiw+x0AsF4EZEaC3e8AgPUiIDMS7H4HAKwXy7wxMux+BwCsByPIAADQISADAECHKRasKbvfAQCjxggya8budwDAKBKQWTN2vwM2s9MzM3nmHfvz3970Q3nmHftzemam75KAZRKQWTN2vwM2q9MzM3nu0Htzfm4uW667Lufn5vLcofcKyTAiBGTWjN3vgM3qhYceTo2PZ8vE4BW0LRMTqfHxvPDQw32XBiyDgMyasfsdsFktzM6mti99Ba22b8/C7GxPFQErISCzZux+B2xWY1NTaWeXvoLWzp7N2NRUTxUBK2GZN9aU3e+Azej6A/fkyz//7rQvfzntwoXU1q2pV70qe37un/ZdGrAMRpABYA1U1eCD1pY+BoaeEWQAWGUvPPRwtl57bcZuuOEbbRfn5/PCQw9n5/R0j5UByyEg803sfgdwdRZmZ7PluuuWtHmTHowOUyxYwu53AFfPm/RgtAnILGH3O4Crd/2Be9LOncvF+cEylxfn59POncv1B+7puzRgGQRklrD7HcDV2zk9nRsOvifbJidz8cUXs21yMjccfI/5xzAizEFmib3X7M3c/Fwmtk18o83udwArt3N6WiCGEWUEmSXsfgcAbHYCMkvY/Q5gdZyemckz79if//amH8oz79if0zMzfZcELJMpFnwTu98BXJ3TMzN57tB7U+Pj2XLddTk/N5fnDr03MQ8ZRoIRZABYZS889PAgHE8MVgTaMjGRGh/PCw893HdpwDIIyACwyhZmZ1Pbl64IZKMQGB2mWGwQdr8DGB5jU1M5PzeXmviLFYFsFAKjwwjyBmD3O4DhYqMQGG0C8gZg9zuA4WKjEBhtplhsAMe/djzXjl+7pM3udwD9slEIjC4jyBvA3mv25uyFs0va7H4HAHBlBOQNwO53AACrR0DeAOx+BwCwesxB3iDsfgcAsDqMIAMAQIeADAAAHaZY9MjudwAAw8cIck/sfgcAMJx6CchVtauqPlJVx6rqC1X1fX3U0Se73wEADKe+plh8IMnHWms/VlXjSXb0VEdv7H4HADCc1n0EuaquSzKd5KEkaa2da62dWu86+mb3OwCA4dTHFItvTTKX5N9V1R9W1Yeq6lWXnlRV76yqJ6vqybm5ufWvco3Z/Q5YDxu9LwVYC30E5G1JvjvJv26t/bUkf57k5y49qbX2wdbavtbavsnJyfWucc3Z/Q5YDxu9LwVYC33MQZ5NMttae2Lx8UfyEgF5M7D7HQDA8Fn3EeTW2leSPFtVr19selOSP1nvOgAA4KX0tYrFu5L8+uIKFk8n+Qc91QEAa+L0zExeeOjhLMzOZmxqKtcfuCc7p6f7LgtYhl4Ccmvts0n29XHvq2X3OwBeyemZmTx36L2p8fFsue66nJ+by3OH3pscfI+QDCPATnorYPc7AJbjhYceHoTjicFmUFsmJlLj43nhoYf7Lg1YBgF5Bex+B8ByLMzOprZvX9JW27dnYXa2p4qAlRCQV+D4145n+9alHZ7d7wC41NjUVNrZpZtBtbNnMzY11VNFwEoIyCtg9zsAluP6A/eknTuXi/ODzaAuzs+nnTuX6w/c03dpwDIIyCtg9zsAlmPn9HSu/dEfzfnnn8//+K//Neeffz7X/uiPeoMejAgBeQXsfgfAcpyemclXP/rRbHv1q/Mtr399tr361fnqRz+a0zMzfZcGLENf6yCPLLvfAfBKuqtYJElNTOTiYrtRZBh+RpABYJVZxQJGm4AMAKvMKhYw2jZFQH589vEc+PiB3PVbd+XAxw/Y2AOANWUVCxhtGz4g2/0OgPW2c3o6Nxx8T7ZNTubiiy9m2+RkbrDNNIyMDf8mve7ud0m+cTx89LA32wGwZnZOTwvEMKI2/Aiy3e8AAFiJDT+CvPeavZmbn/vGyHFi9zsA1t7pmZm88NDDWZidzdjUVK4/cI8RZRgRG34E2e53AKy30zMzee7Qe3N+bi5brrsu5+fm8tyh99ooBEbEhg/Idr8DYL11NwqpqsFxfDwvPPRw36UBy7Dhp1gkdr8DYH0tzM5my3XXLWmzUQiMjg0/ggwA681GITDaBGQAWGU2CoHRJiADwCqzUQiMtk0xBxkA1puNQmB0GUEGAIAOARkAADoEZAAA6BCQAQCgQ0AGAIAOARkAADoEZAAA6BCQAQCgQ0AGAIAOARkAADoEZAAA6BCQAQCgQ0AGAIAOARkAADoEZAAA6BCQAQCgQ0AGAIAOARkAADoEZAAA6BCQAQCgQ0AGAIAOARkAADoEZAAA6BCQAQCgQ0AGAIAOARkAADoEZAAA6BCQAQCgo7eAXFVbq+oPq+p3+qoBAAAu1ecI8n1JvtDj/QEA4Jv0EpCrairJjyT5UB/3BwCAy+lrBPlXkvxskos93R8AAF7SugfkqnpLkhOttU+/wnnvrKonq+rJubm5daoOYGPRlwKsXB8jyN+f5O6q+tMkv5HkB6vq3196Umvtg621fa21fZOTk+tdI8CGoC8FWLl1D8ittZ9vrU211l6X5O1J/nNr7SfXuw4AAHgp1kEGAICObX3evLV2JMmRPmsAAIAuI8gAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANAhIAMAQIeADAAAHQIyAAB0CMgAANBRrbW+a3hFVTWX5JlVuNSrkzy/CtdZbepaGXWt3LDWpq7le761dtfVXEBf2pthrSsZ3trUtTLqWr5l9aUjEZBXS1U92Vrb13cdl1LXyqhr5Ya1NnWNpmH9+qhr5Ya1NnWtjLpWnykWAADQISADAEDHZgvIH+y7gMtQ18qoa+WGtTZ1jaZh/fqoa+WGtTZ1rYy6VtmmmoMMAACvZLONIAMAwMsSkAEAoGPTBOSq2lpVf1hVv9N3LV9XVbuq6iNVdayqvlBV39d3TUlSVT9TVUer6vNV9eGq2t5jLQ9X1Ymq+nyn7fqqeqyqvrh43D0kdb1/8d/yj6rqo1W1axjq6jz3j6uqVdWrh6WuqnrX4tfsaFX98nrXdbnaquq7qur3q+qzVfVkVf3PfdQ2jIaxL030p8uoYyj70pepTX+6wrr67k83Wl+6aQJykvuSfKHvIi7xgSQfa63dkuSvZgjqq6q9SX46yb7W2huSbE3y9h5LOpzk0gW9fy7JJ1tr357kk4uP19vhfHNdjyV5Q2vtO5M8leTn17uovHRdqaobk/xwki+td0GLDueSuqrqbyR5a5K/2lq7NckDPdSVvPTX7JeT/J+tte9KcnDxMQPD2Jcm+tNXcjjD2Zcm+tOVOpzh7E+/qa6McF+6KQJyVU0l+ZEkH+q7lq+rquuSTCd5KElaa+daa6f6reobtiWZqKptSXYk+XJfhbTWZpK8cEnzW5P82uLHv5bkbetaVF66rtbaJ1pr5xcf/n6SqWGoa9G/TPKzSXp5V+5l6vqpJL/UWvsfi+ecWPfCctnaWpJrFz++Lj3+DAyTYexLE/3pcgxrX5roT1dqWPvTjdaXboqAnORXMvhmvth3IR3fmmQuyb9bfLnyQ1X1qr6Laq0dz+A3zy8l+bMkL7bWPtFvVd/khtbany1+/JUkN/RZzGXck+TRvotIkqp6a5LjrbXP9V3LJW5OcntVPVFV/09V/fW+C+r4P5K8v6qezeDnoY/Rq2E0jH1poj+9UqPQlyb60+UY1v50ZPvSDR+Qq+otSU601j7ddy2X2Jbku5P869baX0vy5+nv5a1vWJyD9tYM/sP5y0leVVU/2W9Vl9cG6xQO1VqFVfULSc4n+fUhqGVHkndn8NLWsNmW5Pok35vknyT5zaqqfkv6hp9K8jOttRuT/EwWRyY3syHuSxP96VUbxr400Z+uwLD2pyPbl274gJzk+5PcXVV/muQ3kvxgVf37fktKkswmmW2tPbH4+CMZdPB9+6Ek/721NtdaW0jy20lu67mmSz1XVX8pSRaPvbw0/1Kqan+StyT5e204Fhn/tgz+c/7c4s/AVJLPVNX/1GtVA7NJfrsN/L8ZjEqu+xteLuMdGXzvJ8l/TDIybyxZQ8Palyb60ys1tH1poj9doWHtT0e2L93wAbm19vOttanW2usyeHPEf26t9f4bfGvtK0merarXLza9Kcmf9FjS130pyfdW1Y7F3z7flCF4s8slHsnghy6Lx//UYy3fUFV3ZfDy892ttTN915MkrbU/bq3taa29bvFnYDbJdy9+//Xt/07yN5Kkqm5OMp7k+V4r+gtfTvIDix//YJIv9ljLUBjWvjTRn16FoexLE/3pFRjW/nR0+9LW2qb5k/z/7d3Pqk5RHAbg9xdxhAHHxNDcQMlEBjoXYmLqJpRyC+aEsQxlqORPnCjFQHER6qRlsL/BSvnqmKy9Ts9Te/RN3r52b2+7tdu5meT56BxdnitJ3ibZz3JznxudaZPrbpIvST4leZjk5MAsT7Kc3TvIUka3k+xmeeP6a5IXSc6vJNe3JD+SfNhcD9aQ66/fvye5sIZcWQr80eY+e59kb0X32I0k75J8TPI6ydUR2dZ6ra1LN5n06fYcq+zSLdn06eH+r+F9etS61KemAQCgc+SPWAAAwGEYyAAA0DGQAQCgYyADAEDHQAYAgI6BDAAAHQMZAAA6BjL8Q1Vdq6r9qtqpqtNV9bmqLo/OBTAbfcpsfCgEtqiqe0l2kpxK8rO1dn9wJIAp6VNmYiDDFlV1IsmbJL+SXG+t/R4cCWBK+pSZOGIB2+0mOZPkbJYnHwD8H33KNDxBhi2q6lmSp0kuJbnYWrszOBLAlPQpMzk+OgCsVVXdSnLQWntcVceSvKqqvdbay9HZAGaiT5mNJ8gAANBxBhkAADoGMgAAdAxkAADoGMgAANAxkAEAoGMgAwBAx0AGAIDOH1Ozm0lsiNy9AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "import pandas as pd\n", "from pandas import Series,DataFrame\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "anscombe=sns.load_dataset(\"anscombe\", engine=\"python\")\n", "sns.lmplot(x=\"x\",y=\"y\",data=anscombe,fit_reg=False)\n", "plt.show()\n", "\n", "sns.lmplot(x=\"x\",y=\"y\",data=anscombe,fit_reg=False,hue=\"dataset\",col=\"dataset\",col_wrap=2)\n", "plt.show()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## ファイルからデータを読み込む\n", "### テキストファイルからデータを読み込む" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "..........\n", "----------------------------------------------------------------------\n", "Ran 10 tests in 0.005s\n", "\n", "OK\n" ] } ], "source": [ "import unittest\n", "\n", "\n", "def calculate_mean(numbers):\n", " s = sum(numbers)\n", " N = len(numbers)\n", " mean = s / N\n", "\n", " return mean\n", "\n", "'''\n", "ファイルに格納した平均を計算\n", "'''\n", "def read_data(filename):\n", " numbers = []\n", " with open(filename) as f:\n", " for line in f:\n", " numbers.append(float(line))\n", " return numbers\n", "\n", "\n", "class TestReadData(unittest.TestCase):\n", " def test_01(self):\n", " data = read_data('mydata.txt')\n", " mean = calculate_mean(data)\n", " self.assertEqual(mean, 477.75)\n", "\n", "\n", "if __name__ == '__main__':\n", " unittest.main(argv=['first-arg-is-ignored'], exit=False)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### CSVファイルからデータを読み込む" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import seaborn as sns\n", "\n", "'''\n", "CSVファイルからデータを\b読み込む\n", "'''\n", "import csv\n", "import matplotlib.pyplot as plt\n", "\n", "def scatter_plot(x, y):\n", " plt.scatter(x, y)\n", " plt.xlabel('Number')\n", " plt.ylabel('Square')\n", " plt.show()\n", "\n", "def read_csv(filename):\n", " numbers = []\n", " squared = []\n", " with open(filename) as f:\n", " reader = csv.reader(f)\n", " next(reader)\n", " for row in reader:\n", " numbers.append(int(row[0]))\n", " squared.append(int(row[1]))\n", " return numbers, squared\n", "\n", "if __name__ == '__main__':\n", " numbers, squared = read_csv('numbers.csv')\n", " scatter_plot(numbers, squared)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "[https://www.google.com/trends/correlate/](https://www.google.com/trends/correlate/)" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Highest correlation: 0.9643403143357506\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "import seaborn as sns\n", "\n", "def read_csv(filename):\n", "\n", " with open(filename) as f:\n", " reader = csv.reader(f)\n", " next(reader)\n", "\n", " summer = []\n", " highest_correlated = []\n", " for row in reader:\n", " summer.append(float(row[1]))\n", " highest_correlated.append(float(row[2]))\n", "\n", " return summer, highest_correlated\n", "\n", "def scatter_plot(x,y):\n", " plt.scatter(x,y)\n", " plt.xlabel('Number')\n", " plt.ylabel('Square')\n", " plt.show()\n", " \n", "def find_corr_x_y(x,y):\n", " n = len(x)\n", " # 積の和を求める\n", " prod = []\n", " for xi,yi in zip(x,y):\n", " prod.append(xi*yi)\n", " sum_prod_x_y = sum(prod)\n", " sum_x = sum(x)\n", " sum_y = sum(y)\n", " squared_sum_x = sum_x**2\n", " squared_sum_y = sum_y**2\n", " x_square = []\n", " for xi in x:\n", " x_square.append(xi**2)\n", " # 和を求める\n", " x_square_sum = sum(x_square)\n", " y_square=[]\n", " for yi in y:\n", " y_square.append(yi**2)\n", " # 和を求める\n", " y_square_sum = sum(y_square)\n", "\n", " # 式を使って相関を計算\n", " numerator = n*sum_prod_x_y - sum_x*sum_y\n", " denominatior_term1 = n*x_square_sum - squared_sum_x\n", " denominatior_term2 = n*y_square_sum - squared_sum_y\n", " denominator = (denominatior_term1*denominatior_term2)**0.5\n", " correlation = numerator/denominator\n", "\n", " return correlation \n", "\n", "\n", "if __name__ == '__main__':\n", " summer, highest_correlated = read_csv('correlate-summer.csv')\n", " corr = find_corr_x_y(summer, highest_correlated)\n", " print('Highest correlation: {0}'.format(corr))\n", " scatter_plot(summer, highest_correlated)\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "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.7.0" } }, "nbformat": 4, "nbformat_minor": 1 }